agentic-kb
Make product direction, decisions, and context travel at the same speed as creation.
AI-native knowledge ops for roadmaps, journeys, decisions, and cross-role handoffs. Vendor-neutral. No database. Lives in your repo.
- "We're shipping more than ever and feel blurrier about where we're going."
- "I can't review every direction fast enough to say yes or no."
- "My agents are aligned with me. Yours are with you. We're not aligned with each other."
- "By the time leadership catches up, another three things got built."
Proof strip
The quickest credible adoption story is not a bigger architecture pitch. It is one short path a team can run and inspect.
1. Install
Wire one harness into its documented native command or skill surface.
2. Scaffold
Create one anchor layer plus one adjacent shared layer with the same file contract.
3. Capture
Turn one source into a finding/topic update that another human can review.
4. Promote + digest
Exercise the shared loop once so the governance story is visible, not implied.
5. Verify
Regenerate reports and run the repo-owned fixtures that prove the same path in CI.
GitHub as an operating backbone
If a team already runs on GitHub Issues, Projects, and pull requests, /kb setup can generate a generic governance profile instead of leaving adopters to invent the issue/project/PR rules themselves.
Issue forms
Feedback, ideas, decisions, tasks, bugs, features, roadmap items, content updates, and governance changes get typed intake.
PR discipline
The PR template ties changes back to tracker items, KB artifacts, validation, changelog impact, and safe review.
Governance CI
A workflow checks template syntax, unresolved placeholders, linked issues or explicit exceptions, version-impact policy, and skill presence.
Agent parity
A repo-local tracker workflow skill teaches agents the same issue/project/PR rules that CI and reviewers enforce.
Setup also stages a path labeler and a manual checklist for native issue types, project/status fields, labels, milestones, branch protection, CODEOWNERS, parent/sub-issues, and required checks. The profile stays generic: no organization names, product-specific labels, or hardcoded project IDs.
The real problem
Your agents made you 10× faster at creating. Nothing made you faster at deciding. The bottleneck didn't move to design, quality, or testing.
It moved to convergence.
Creation at agent speed. Decisions at human speed. That gap is where budgets burn, alignment erodes, and smart teams end up running in three directions at once.
Product direction is where the gap becomes painfully visible: roadmaps drift from delivery reality, journeys live in slides instead of source control, and stakeholder alignment depends on who saw the latest deck.
agentic-kb is the piece of the fix that puts roadmaps, journeys, decisions, ideas, goals, and context on the same rails as the output — so a human at any level can stay in the loop with a swarm of agents and a team of other humans, without becoming the bottleneck.
Why it's built this way
🗂 No database
Plain Markdown in a git repo. Your KB versions like code, reviews like code, diffs like code. If a folder can read it, this works.
☁️ No cloud backend
No SaaS. No auth. No infra. Your knowledge stays on your disk. If the vendor disappears tomorrow, your KB is still there.
🔓 No vendor lock-in
Claude Code and VS Code have marketplace/native plugin paths. OpenCode, Gemini, and Kiro get installer-backed native entrypoints. Codex uses the same repo contract via AGENTS.md plus a reusable kb skill.
🪶 Lean by construction
One spec. Two reference skills. One reference agent. One installer. Install in about a minute. Rip it out in five if it's not for you.
Where this meets you on the agentic curve
You don't have to be "fully agentic" for agentic-kb to pay off. Same contract at every stage — the agent just does more of the filing work the higher you go.
Stage 1 — Capture discipline
Human-only baseline. Just git + markdown + the agentic-kb directory contract. No agents required. You get audit trail, decision lifecycle, and cross-role handoffs for free, just by writing into the right files.
automation: none
Stage 2 — Agent-assisted triage
The /kb evaluation gate fires on capture; agent proposes where things belong; humans approve before anything persists. The handoff surfaces stay yours.
automation: level 1
Stage 3 — Bounded autonomous
Scheduled rituals, guarded auto-promote on confidence, exception escalation. Humans review only flagged items, not every line.
automation: levels 2–3
agentic-kb is the knowledge-ops layer of an agentic enterprise — it owns Strategy, Product Direction, Design, Delivery, Operations, and Learning artifacts (foundation, roadmaps, journeys, briefs, specs, decisions, findings, topics, reports, releases, incidents) and pairs cleanly with any repo-as-OS framework that owns the work-flow side (signals, missions, PRs, releases). Standalone is also a valid stop — capture-discipline-only is not a half-installed product.
Right move for most teams: start at Stage 1, graduate when the workflow is steady, never skip ahead.
Flexible layers, one command
A workspace is a layer graph, not a fixed ladder. Each layer has a name, a scope, a role, and a parent edge. Knowledge flows up via promote; context flows down via digest. Here is the most common shape — your graph can have fewer or more layers, and your anchor (the layer that holds .kb-config/) does not have to be personal.
alice-personal
contributor
team-observability
contributor
engineering-org
contributor
company-guidance
consumer · read-down only
At least one contributor-capable layer is required. A personal anchor is recommended but not mandatory. promote and publish into a consumer layer are refused with a clear message.
Marketplaces are cross-cutting, not a slot in the chain. Any layer can attach its own marketplace repo for skills it wants to share with that audience.
The evaluation gate
Applied at every persistence boundary. This is the system's immune system — nothing persists without earning its place.
- Does this strengthen a position?
- Does this inform a decision?
- Would you reference this again?
- Is this actionable?
- Does this already exist?
First-class building blocks
Every primitive is a file with a contract. Layers opt in to the ones they need.
findings/
Dated, immutable snapshots. The evidence base.
topics/
Living positions. Updated in place with changelog.
decisions/
Open or resolved choices with evidence trail and stakeholders.
ideas/
Incubation objects. Seed → growing → ready → shipped.
notes/
Meeting and working notes — first-class, not chat noise.
tasks/
Focus and backlog with explicit creation and closure.
foundation/
Identity: who you are, your context, sources, stakeholders.
workstreams/
Parallel tracks with their own themes and active decisions.
roadmaps/
Phase/lane plans that reconcile customer value, plan truth, and delivery reality.
journeys/
User, customer, operator, or product flows that ground roadmap scope in lived experience.
delivery/
Briefs and specs that make direction executable without losing intent.
operations/
Release and incident records that feed learning back into the KB.
One command: /kb
The agent infers the layer and action from context. No subcommand memorization needed.
/kb [text] — capture + evaluate
/kb review — process inbox
/kb promote [file] [layer] — promote upward
/kb digest [layer] — pull parent-layer changes
/kb digest connections — pull repo / tracker deltas
/kb note meeting [topic] — start a meeting note
/kb note retro [topic] — start a retrospective
/kb idea [text] — create idea
/kb develop [idea] — sparring session
/kb decide [desc] — open decision
/kb brief [title] — frame delivery intent
/kb spec [title] — open design contract
/kb release [title] — record rollout and rollback
/kb incident [title] — capture impact and follow-up
/kb task — show focus items
/kb start-day — morning briefing
/kb end-week — weekly summary
/kb present [topic] — HTML slides
/kb report progress [scope] — cross-source report
/kb migrate layer-model — legacy ladder → graph
/kb setup — onboarding wizard
Two product-management subcommands ship with the same plugin and activate only after setup derives or you confirm their owning layer:
/kb roadmap — customer-value phase/lane roadmap (MD + HTML + JSON)
/kb journeys — author + render user/customer/operator journeys with extractable mocks
Product-management skills
The same marketplace install ships roadmap and journey skills next to the core. Setup proposes them when your role, goals, sources, or desired outputs imply roadmap or journey work; expert users can also add the config blocks manually. Same `/kb` surface, no second install.
/kb roadmap · kb-roadmap
Turns dense planning and delivery inputs into a customer-value roadmap: lanes, phases, confidence state, and traceability in one artifact. Emits Markdown, HTML, and JSON, with value-first headlines and explicit proposed/agreed/shipped status.
stable setup-proposed skill · enable via roadmap: on the confirmed owning layer in .kb-config/layers.yaml
/kb journeys · kb-journeys
Authors hierarchical journeys (journey → phase → sub-journey → step) with entry/exit conditions, interfaces, and per-step readiness. Journeys become the product-management ground truth that roadmap items cite, review, and move forward.
stable setup-proposed skill · enable via journeys: on the confirmed owning layer + journeys-template: in .kb-config/artifacts.yaml
Both skills share an authoring arc — ideate · discuss · review · refine — and treat the journey as the third party in every roadmap critique when both are enabled.
Decisions & ideas as first-class objects
Decisions
Tracked with evidence trails, stakeholders, RACI, and due dates. Not buried in prose.
gathering-evidence → under-discussion → proposed → decided → archive
Ideas
Observations with novelty value get incubated. The agent plays devil's advocate via /kb develop.
seed → growing → ready → shipped | archived
Cross-agent portable
One source of skills and commands feeds every documented harness tier. The workflow stays the same even when the invocation surface changes.
Claude Code
.claude/skills/
VS Code Copilot
.github/skills/
OpenCode
.opencode/skills/
Gemini CLI
.gemini/commands/
Kiro IDE
.kiro/skills/
Codex CLI
.agents/skills/ + AGENTS.md
Support tiers
Marketplace/native plugin
Claude Code exposes a stable native /kb install path. VS Code Copilot Chat exposes a Preview path (chat.plugins.marketplaces) plus a stable installer fallback.
Installer-backed native surface
OpenCode, Gemini CLI, and Kiro IDE get their documented command or skill entrypoint from scripts/install.
Compatible skill workflow
Codex CLI uses the same workspace contract through AGENTS.md plus the installed kb skill.
Get started
Claude Code
/plugin marketplace add https://github.com/wlfghdr/agentic-kb
/plugin install kb@agentic-kb
/kb setupVS Code Copilot Chat (Preview)
// user-level settings.json
// (VS Code Agent plugins are a Microsoft Preview feature)
"chat.plugins.marketplaces": [
"wlfghdr/agentic-kb"
]
// install from Extensions view, then:
/kb setup
// Stable alternative:
// scripts/install --target vscodeOpenCode / Gemini / Kiro / Codex
git clone https://github.com/wlfghdr/agentic-kb
cd agentic-kb
scripts/install --target <harness> --global
# then: /kb setup/kb setup walks you through name, role, workstreams, layer graph, branding, and optional integrations. See the README for the full per-harness install matrix.