What exists in the code now?
Semantic search, symbol graphs, history, references and dependencies give agents an accurate view of the software.
SOURCEGRAPH · AUGMENTCarabase Code · Project context for coding agents
Your agents can read the code. We remember why it exists.
Carabase Code gives every coding agent the evidence, intent, decisions, current state and remaining gaps behind a project—then turns completed work into reviewed, durable project memory.
Agent-neutral via MCP · Evidence-backed · Human-governed
YOUR AGENT
Preparing the checkout refactor. What do I need to know first?
CARABASE
The mission is one-click renewal without weakening billing controls. Entitlement changes stay behind settled payment events—that decision is accepted, not up for relitigating. Webhook idempotency shipped in PR #842 and passed the replay suite. The retry path still lacks a concurrency test.
D-018 · accepted decision
PR #842 · validated
The category
Three systems. One complete agentic stack.
The strongest engineering systems specialise. Code intelligence explains the codebase. Agent runtimes plan and execute. Carabase Code preserves the project's longitudinal meaning and serves it to both.
What can we do next?
Coding agents inspect, plan, edit, test, review and ship. They turn context into action inside the development loop.
DEVIN · CODEX · CLAUDE CODEWhy does it exist—and what did the work change?
Carabase connects intent to decisions, decisions to implementation, implementation to validation, and every outcome to the gap that remains.
CARABASE CODEThe context gap
The missing layer is not more code search.
Even excellent agents rebuild the project from code, scattered documents, tickets and yesterday's chat. That works—until the invisible reasoning matters.
Intent lives outside the repository.
The desired outcome, the user promise and the strategic constraint rarely fit cleanly in code.
Decisions decay into folklore.
Accepted trade-offs and rejected paths disappear into meetings, chats and individual memory.
Sessions end without semantic closure.
The diff survives. What advanced, what was validated and what remains often does not.
Every new agent pays the reconstruction tax.
Teams spend tokens and attention rediscovering a project state they already knew yesterday.
The closed loop
Useful before the first edit. Smarter after the last test.
Carabase is not a static knowledge base beside the work. It is the context loop around the work: compile, retrieve, reconcile.
Before: compile the task context.
One call returns the mission, live initiatives, governing decisions, recent outcomes, contradictions and cited evidence relevant to this task.
OUTPUT · PROJECT CONTEXT PACK
During: retrieve meaning on demand.
The agent inspects the exact evidence behind a claim, traverses the project why-chain, and distinguishes accepted decisions from proposals.
OUTPUT · GROUNDED RETRIEVAL
After: propose what changed.
The agent submits a reviewable semantic delta: outcome, validation, decision advanced, evidence created and the gap that remains. Humans decide what becomes durable memory.
OUTPUT · CONTEXT COMMIT
INTENT → DECISION → REQUIREMENT → IMPLEMENTATION → VALIDATION → REMAINING GAP
Agent startup
A context pack, not a document dump.
Deterministically assembled from stored project memory, ranked by the task and target paths. The smallest useful slice of project truth—and an honest account of where truth is missing.
Document dumpEvery other setup
“Here is the wiki, the tickets and last month's chat. Good luck.”
Unranked prose burns the context window and hides what is settled, what is stale and what was quietly contradicted.
With CarabaseTask-scoped
“The smallest useful slice of project truth.”
- Mission — what the project is trying to achieve
- State — live initiatives and recent outcomes
- Rules — accepted decisions and invariants
- Gaps — contradictions, unknowns and stale areas
- Evidence — resolvable citations for every admitted claim
Context Commit
The semantic equivalent of a git commit.
Git records how files changed. A Context Commit records how project meaning changed. It is structured, attributable, reviewable and idempotent—so agents can propose memory without silently rewriting history.
This is the compounding loop: each completed task leaves the next agent session better briefed than the last.
outcome: settlement ledger shipped in PR #842
validation: replay suite 48/48 passing
decision advanced: D-018 webhook authority
gap: concurrent retry path remains untested
gap resolved: duplicate event persistence
Human review required · Proposed
Trust model
Memory is only valuable when you can challenge it.
Carabase treats provenance, authority, contradiction and review as product primitives—not metadata to add later.
EVIDENCEEvery claim resolves back to its source artifact, excerpt, test, pull request or session.
AUTHORITYAuthored, accepted, observed and derived records stay distinct. Proposals never masquerade as decisions.
CONTRADICTIONConflicting records and stale projections surface for reconciliation, not silent overwriting.
GOVERNANCEAgents retrieve freely and propose updates. Durable project memory remains a human decision.
Like everything Carabase, project memory lives on hardware you control. Your agents get better context without your project history being surrendered to a single model, IDE or execution platform.
Working now
Cited project context over MCP, today.
Carabase already captures coding sessions and project evidence, compiles deterministic task context, ranks it by target path and reports its own coverage gaps. Reviewed Context Commits, typed why-chains and repository projections close the rest of the loop—we ship against that daily.
Folios
Project folios and evidence
Sessions, decisions and outcomes retained with provenance.
Packs
Deterministic context packs
Task-scoped briefings ranked by target paths.
MCP
Agent-neutral retrieval
Codex, Claude Code and local agents share one project memory.
Honest
Provenance and uncertainty
Coverage gaps are reported, never papered over.
Private alpha
Give every agent the project you already know.
Carabase Code is for teams that want better agents without surrendering project memory to a single model, IDE or execution platform. It ships with the same host, the same privacy architecture and the same private alpha as the rest of Carabase.