The knowledge base
your agents
deserve
Persistent, scalable context for AI agents and their humans — with code intelligence, a knowledge graph, and distributed sync built in.
Ten agents on your machine. Ten thousand across your org. One knowledge layer where agents and engineers create, refine, share, and discover context together.
100% free for local use. No limits. No account required.
From agents to knowledge engineering at scale
GitKB turns every engineer's work into shared organizational knowledge. Specs, decisions, architecture, and code intelligence flow across repos, teams, and agents — so your twentieth engineer benefits from what the first ten learned.
Multi-repo
One knowledge base spans your entire workspace. Cross-project context without context switching.
Multi-agent
Agents pick up where others left off. No re-explaining, no duplicated work, no conflicting decisions.
Multi-team
Shared graph, shared conventions, shared memory. New engineers and new agents onboard from the same source of truth.
Knowledge Graph
Documents, tasks, and code linked by typed relationships. Wikilinks, backlinks, and automatic edge extraction — your agent navigates the full picture.
Code Intelligence
Call graphs, impact analysis, and dead code detection across 17 languages. Agents get exact call sites, not grep matches.
Commit-Based Versioning
Every change is a versioned commit with full diffs and BLAKE3 integrity. Complete audit trail for every agent action.
This is how engineering organizations transition to agentic coding — not one developer at a time, but as a connected system where every contribution makes the whole team faster and more confident.
Evaluating for your team? Join the Alpha"What's next?"
One question. Full project state in seconds. No re-explaining, no digging through files, no lost context.
What your agents are missing
AI agents are powerful — until they forget everything, search blind, and lose track of why.
Your agent starts every session from zero.
Every restart wipes the slate. Project context, decisions made, progress tracked — gone. You re-explain the same architecture, the same patterns, the same constraints. Session after session.
GitKB gives agents persistent memory that survives restarts, compactions, and handoffs. Context loads in milliseconds. Cold starts become warm starts.
Your knowledge lives everywhere except where it's useful.
Architecture in Google Docs. Tasks in Jira or Linear. Patterns in someone's head. Code conventions in a README nobody reads. Your agent can't search what it can't reach.
One local knowledge base that lives alongside your code. Structured documents, typed relationships, and code intelligence — all connected in a queryable graph. Full-text search across everything in milliseconds.
Agents change code they don't understand.
They grep for patterns, guess at callers, and miss dependencies. One rename breaks five files they never checked. You're left fixing what the agent broke.
GitKB indexes call graphs across 17 languages. Agents see every caller, every callee, and the full blast radius — and find dead code before it accumulates.
There's no record of why.
Agents make decisions, write code, close tasks. Then context resets and the reasoning evaporates. No audit trail. No breadcrumbs. The next session starts from scratch with no idea what happened or why.
Every change is a versioned commit. Full history with diffs, linked to the tasks and specs that motivated them. Decisions, progress, and rationale — all preserved and searchable.
Your task board doesn't know about your codebase.
Tasks live in one tool, code in another, specs in a third. Nothing links a task to the function that implements it, or the spec that motivated it. Agents work without the full picture.
Documents, tasks, and code connected by typed relationships in a knowledge graph. Agents traverse from task to spec to function to caller — the whole picture, instantly.
Every session makes the next one better
Every document you create expands the knowledge graph. More edges, richer search, higher-confidence decisions. Your agent doesn't just remember — it compounds.
Structure that builds itself
Every document you create automatically generates typed relationships — the graph wires itself together. Your context becomes queryable infrastructure without extra work.
Recover when plans change
When an agent hits something unexpected mid-task, it traverses the graph — parent tasks, related specs, architecture docs — and course-corrects instead of starting over.
Compound over time
Every session's output becomes the next session's input. More documentation, more links, more context. The graph gets denser, and every agent starts stronger than the last.
Your knowledge base isn't just a record — it's a safety net. Agents cold-start with confidence, recover from surprises mid-task, and leave the graph richer for the next one.
Up and running in under a minute
No accounts. No configuration. Just install and go.
Install
One command to install.
Initialize & Index
Point it at your project.
Search & Build
Start querying your knowledge.
"Can't I just use markdown files in Git?"
You can. Everyone starts there. Here's why everyone stops.
Commit docs alongside code. Pollute every PR.
Every spec update, task edit, and context change shows up in your code diffs. Your commit history becomes noise. Reviewers see doc changes in code PRs. Your .gitignore grows. The repo gets heavy.
Separate knowledge store. Clean code repo.
GitKB lives in .kb/ with its own commit history, its own versioning, its own search index. Your code stays clean. Your knowledge stays structured. Neither pollutes the other.
Hide docs on an orphan branch. Lose visibility.
The "clever" workaround. Push docs to a separate branch so they don't touch code. Now they're invisible to your agent, unsearchable without checkout, and forcibly scoped to one repo. Cross-project knowledge? Doesn't exist.
Always available. Spans every repo.
Knowledge is always queryable, always indexed, always ready for your agent. One knowledge base spans your entire workspace — across repos, across projects. No branch switching. No scope limits.
Grep for what you need. Hope you spell it right.
grep -r "auth" docs/ returns 200 lines. No ranking. No relationships. You can't ask "what blocks this task?" or "show me all specs related to authentication." Files are just files.
Ranked search. Graph traversal. Milliseconds.
Full-text search with BM25 ranking, relationship-aware graph traversal, and typed document filtering. Ask git-kb search "retry" and get ranked results across specs, tasks, incidents, and code — instantly.
Flat files. No connections. No intelligence.
A markdown file in Git knows nothing about your codebase. It doesn't know which function implements the spec it describes. It doesn't know which task it blocks. It's just text in a file.
A knowledge graph that understands your code.
Documents connect to code via typed relationships. Specs link to tasks. Tasks link to functions. GitKB indexes call graphs across 17 languages — your agent sees every caller, every dependency, every blast radius.
Git versions files. Not knowledge.
Git tracks line changes in individual files. It can't atomically version a set of related documents. It has no concept of document types, statuses, or task boards. You're building a knowledge base on top of a file versioning tool.
Built to version knowledge, not just files.
Atomic multi-document commits. BLAKE3 integrity hashing. Structured diffs that understand frontmatter, relationships, and document types. A commit in GitKB means something — not just "files changed."
Git is brilliant at versioning code. GitKB is built for everything else — the specs, tasks, context, and relationships that make your agent effective. They're complementary, not competing.
Simple, transparent pricing
Local is free forever. Pay only when you need cloud sync and team features.
Local
For individuals and open source
- Unlimited documents
- Full-text search (BM25)
- Knowledge graph with wikilinks
- Code intelligence (17 languages)
- 42 MCP tools (local)
- 80+ CLI commands
- Version control with BLAKE3 integrity
Team
For teams that need sync
- Everything in Local
- Cloud sync & backup
- Unlimited knowledge bases
- 5 GB storage included
- Full API access
Business
For organizations at scale
- Everything in Team
- 50 GB storage included
- 500K indexed code symbols
- SSO / SAML / OIDC
- 1-year audit log
- Priority support
Enterprise
Custom infrastructure
- Everything in Business
- Self-hosted / on-premise
- Custom integrations
- Dedicated support
Get started
Local and free forever. No account required. Install and start building in under a minute.