AST queries in 1 ms.
Language-aware parsing for 7 languages. Find a function, its callers, every symbol — answered from an index, not file scans.
P501.2 ms
Built for the agentic codebase.
From the ground up.
Three ideas in one product: a unified MCP server, code-aware memory anchored to AST nodes, and a four-role A2A swarm with per-role persistent memory. Built on 1536-dim exact-cosine vectors — 100% recall, not approximate.
MCP TOOLS39 shipped
VECTOR RECALL100% · 1536-dim
TOKEN SAVE95% + 83%
A2A HANDOFFPointer-sized
CODE INTELLIGENCE · NATIVE TO THE DATABASE
Code intelligence, native to the database.
Git stores files as opaque blobs. gitdb.co parses every file on ingest and indexes structure as columnar data, so agents query the AST instead of greping it.
Semantic search at 100% recall.
Ask in plain English, get the matching code. 1536-dim exact-cosine vector search — not approximate. The right span is ranked #1, not somewhere in the top-K.
RECALL100% · exact
Branch isolation for agents.
Concurrent agents commit to their own branches. Three-way merge reconciles when the work is done — no agents stomping on each other's edits.
MERGEThree-way
IDEA 1 · UNIFIED MCP INTERFACE
One MCP server. 39 tools. Every agent IDE.
MCP-native from day one. Point Claude Code, Cursor, or Windsurf at a single URL and the whole surface lights up — code intelligence, memory, and branch isolation all on the same API key.
39 MCP tools shipped.
Read, write, commit, diff, merge, AST queries, semantic search, code-aware memory — all callable over MCP-SSE or stdio. Agents pass database pointers, not raw code, on every call.
TOOLS39
95% fewer tokens per read.
AST-aware reads return the exact function, span, or struct the agent asked for — not the whole file. On real workloads, agents burn ~5% of the tokens they would on file_read.
TOKEN SAVE95% per read
Code off the laptop.
Our VS Code extension reads files via the gitdb:// scheme straight from the database. Close the editor and no source sticks around on the developer machine.
ON-DISK COPIES0
IDEA 2 · CODE-AWARE MEMORY
Memory that knows what your code looks like.
Generic agent memory treats your codebase as flat text. gitdb pins every memory to the exact AST node it was about — and tells you when that code has changed. Your agents stop re-discovering the same bug twice.
AST-anchored memories.
Store a fix, a gotcha, or an architectural decision and it's pinned to the function, struct, or file span it describes — not a free-text label that drifts.
ANCHORAST node
Stale detection built in.
Every recall checks the content hash of the anchored code. If the underlying function changed, the memory comes back flagged stale — so your agent knows when to trust it.
FRESHNESSPer-call
Stacks 83% on top of AST.
AST reads already cut ~95% of tokens. Memory recall cuts another ~83% on tasks the agent has seen before. A 20K-token task drops to ~2K. The savings compound, they don't compete.
TOKEN SAVE83% per task
IDEA 3 · A2A SWARM WITH PERSISTENT MEMORY
Agent teams that get smarter every task.
Architect, Coder, Reviewer, Tester — coordinated multi-agent workflows with per-role persistent memory. Each role has its own memory collection, so the swarm learns over time instead of starting cold on every task.
Four roles, ready out of the box.
Architect plans, Coder writes, Reviewer merges, Tester verifies — each with its own allowed-tool set and handoff rules. Or define your own roles; memory is scoped to whatever role name your agents pass.
ROLESArchitect · Coder · Reviewer · Tester
Per-role persistent memory.
Each agent role gets its own memory collection — architectural decisions for the architect, gotchas for the coder, review patterns for the reviewer, flaky areas for the tester. Cross-task learning, no stale-context drift.
COLLECTIONSPer role
Handoffs are pointers, not code.
A handoff carries file paths and line ranges, not raw code. The next agent reads what it needs from gitdb directly.
HANDOFFPointer-sized
TOKEN ECONOMICS · THE COMPOUND
How a 20K-token task becomes a 2K-token task.
The three ideas above compound. AST-aware retrieval cuts the cost of every read. Code-aware memory cuts the cost of every task the swarm has seen before. Database-pointer handoffs cut the cost of every agent-to-agent exchange. The math, end-to-end:
Single agent, cold task.
Agent fetches the right span via AST query instead of reading the whole file. ~95% reduction vs file_read. A 4K-token read becomes ~200.
BASELINE SAVE95%
Single agent, repeat task.
Memory recall returns the known fix instead of forcing the agent to re-discover it. Stacks on top of AST savings — task that was ~4K tokens drops to ~700.
ON RECURRENCE83% more
Swarm, multi-step task.
Architect → Coder → Reviewer hand off pointers — file paths and line ranges — instead of re-passing code. Persistent per-role memory means each role starts from what it learned on earlier tasks, not from a cold context.
END-TO-END~10× cheaper
Ready to build with
gitdb.co?
Bring your agents to a database built for them. AST-aware retrieval, code-aware memory, and a full A2A swarm — all from $30 per dev per month.