You're mid-session with Claude, debugging a tricky ownership issue in your Rust service. Claude asks you to re-explain the module layout. Again. You paste in the same three files you pasted yesterday, and the day before. Then you switch to Cursor to make the edit, and now Cursor doesn't know what Claude just reasoned through. Then you open a third tool to run a code review, and it knows nothing about either conversation.

We all know this scenario all too well. Its a side effect of an isolated process, tolerated.

The World You're Already Living In

The multi-agent future didn't arrive as a clean architectural decision. It crept in. You added Claude for reasoning-heavy tasks. You kept Cursor because the editor integration is fast. You tried Copilot for autocomplete. Maybe you added a custom agent for your CI pipeline.

Now you have three or four AI systems, each smart in isolation, and none of them talking to each other. Each one has its own model of your codebase: partial, stale, and rebuilt from scratch every session. You're the glue binding them together. You carry context in your head and manage it within each tool.

This isn't a workflow problem. It's a structural problem. The agents are islands.

The Tax You've Been Paying

Let's name the symptoms you've probably stopped noticing because they're just background noise now.

Context resets. Every new session, every tool switch, you start over. Your agent doesn't remember that you refactored the auth module last sprint, or that the UserSession type was deprecated, or that you explicitly decided not to use tokio::sync::Mutex in that service for a documented reason.

Re-explaining. You've written the same architectural summary in at least five different chat windows. You know the one, the paragraph that explains why the service boundary is where it is, what the config crate actually does, why there are two database connection pools. You've typed it so many times you could recite it.

Lossy summarizers. You tried memory layers. They gave you back a vague paraphrase of what you told them: semantically adjacent but structurally wrong. They got the gist and lost the specifics. When the specifics are a function signature or a type constraint, "close enough" is not good enough.

Fragmented context. Your agents disagree because they're working from different snapshots. One knows about the refactor. One doesn't. You spend cognitive cycles arbitrating between them instead of writing code.

None of this is dramatic. It accumulates in small ways until you realize you're spending a meaningful fraction of your day managing what your tools know instead of building things.

What Fabric Is

Fabric is the code intelligence and memory layer for AI coding agents, delivered today through an MCP.

20 MCP tools. 13 languages. One install. Your code never leaves the machine.

One install. Every agent you use (Claude, Cursor, whatever comes next) queries the same structural understanding of your codebase and the same persistent memory of your work.

Four things make it what it is:

Structural code intelligence. Fabric parses your codebase into a graph of symbols, dependencies, call chains, and type relationships. Not a text index. Not embeddings over file chunks. A real structural model that understands what imports what, what calls what, and how data flows through your system.

Persistent memory across sessions and agents. Decisions, context, architectural reasoning, stored once, available everywhere. Not per-session, not per-tool. Persistent.

MCP delivery. Fabric exposes everything through the Model Context Protocol. Any agent that speaks MCP can query it. You don't rewrite your workflow; you add a layer under it.

Deterministic recall. When you ask for a function signature, you get the function signature: exact, byte-perfect. Not a reconstruction. Not a summary. The actual thing.

That last point is where we should spend a moment.

On Determinism (Because This is where we shine)

If you've been burned by memory systems before, you're right to be skeptical. Most of them work like this: they summarize your context into an embedding, store it, retrieve it later via similarity search, and hand the model something that resembles what you said. That's lossy by design. The model fills in gaps. The gaps are where the errors live.

Fabric's approach is different at the architecture level. For structural code artifacts (symbols, signatures, types, dependency edges), Fabric stores and returns the artifact itself. No summarization in the path. No reconstruction. When a tool queries Fabric for the definition of a type, it gets that definition back verbatim.

Fabric's core principle is curation, not retrieval. The goal is not to retrieve text similar to your query. It's to surface the exact, structured artifact your agent needs, ranked by actual relevance to the task at hand.

For memory, the things you've told your agents, the decisions you've made, the context you've established, Fabric uses attention tiers. Not everything you said three months ago is equally relevant right now. Fabric weights recency, salience, and explicit importance markers to surface what's actually useful, not just what's lexically close to your current query.

It also resolves contradictions. If you told Claude one thing in January and something different in March, Fabric knows which is current. It doesn't hand both versions to your agent and let the model guess.

This is not "no hallucinations." Language models do what they do. But when the context Fabric provides is structurally accurate and complete, the model has less to fabricate.

Performance

We benchmark every release against cosign-signed, reproducible artifacts. The numbers below come from our rc.26 metal corpus run (AWS c7i.metal-24xl, verifiable at bench-results:475517e7 via cosign verify-blob):

These are internal benchmarks on a 4-repo subset of our 13-language corpus. Every result is paired with a Sigstore signature you can verify independently before trusting. ContextBench and SWE-bench Lite runs are queued for the next two release cycles.

How It Works in Practice

Install time is around five minutes. Fabric runs as an MCP server. Point your agents at it; they start using it.

npm install -g @cognisos/fabric-mcp@latest

Once installed, configure it as an MCP server in your agent's config:

{ "mcpServers": { "fabric": { "command": "fabric-mcp" } } }

Restart your agent, then index your first repo:

fabric_index
fabric_status

Fabric indexes your codebase. For a mid-sized Rust/Python project (say, 50k–200k lines), initial indexing runs in seconds. After that, it watches for changes and updates incrementally. The structural graph stays current.

When your agent makes a query ("what calls this function," "what's the full type of this struct," "what did we decide about error handling in the payment service"), Fabric handles it. The agent gets back structured, accurate context. It doesn't have to ask you.

The 20 Tools Available Today

Fabric exposes 20 tools over MCP, each addressing a specific class of problem:

Code intelligence: fabric_query, fabric_slice, fabric_text_search, fabric_impact, fabric_explain. Structural answers to structural questions, with no approximation.

Memory and context: Store decisions, retrieve relevant context, query past reasoning, surface related prior work. This is where the cross-session persistence lives.

Codebase navigation: Find usages, trace data flow, locate definition sites, explore module structure. The kind of navigation that used to require a full IDE with a language server.

Governance and policy: fabric_govern lets you encode rules ("all HTTP handlers must call auth_middleware first") that your agent checks before suggesting code. No other code-intelligence tool ships policy enforcement at the index layer.

Cross-agent context: Read and write shared context that any agent can access. This is how you stop being the integration layer.

The net effect: your agents spend less time asking you to repeat yourself and more time doing work that requires them.

Fabric also auto-generates CLAUDE.md, .cursorrules, copilot-instructions.md, and agents.md from the current graph on every index run. The single hardest part of agent-prompt engineering, handled automatically.

Language Support

Fabric indexes 13 languages from a single binary: TypeScript/JavaScript, Python, Go, Rust, Java, C, C++, C#, Ruby, PHP, Swift, Kotlin, and Scala. No per-language orchestration.

For teams already running Sourcegraph, Fabric emits SCIP output from the same index (fabric_emit_scip). One binary feeds your existing Sourcegraph instance instead of five separate indexers. Dual-licensed MIT OR Apache-2.0.

The Curation Difference

Most memory and context systems are retrieval systems. They take your query, find similar stored content, and return it. The model gets a bag of possibly-relevant text and has to figure out what's actually useful.

That's not what Fabric does.

Fabric curates. The distinction matters because curation is opinionated: it has a model of what's relevant and why. When your agent asks about a module, Fabric doesn't return the five most similar chunks. It returns the symbol definitions, the dependency edges, the relevant architectural decisions you've recorded, and the recent changes, ranked and structured so the model gets signal, not noise.

The attention tier system is part of this. Not all context is equal. Something you marked as a core architectural constraint should surface every time it's relevant, even if you said it six months ago. Something incidental from last week might already be stale. Fabric maintains these distinctions so your agents aren't reasoning from outdated or low-signal context.

This also means Fabric gets better as you use it. The more decisions you record, the more context you establish, the more accurately it can serve future queries. It compounds in a way that raw retrieval doesn't.

What Byte-Perfect Recall Actually Means

When Fabric returns a function signature, it returns the function signature. When you ask for the definition of a type, you get the definition: the actual source, not a model's reconstruction of what it thinks the definition probably said.

This matters most at the edges. The places where your code is subtle: type constraints, lifetime annotations, protocol implementations, the specific error variants your service can return. These are exactly the places where a lossy summarizer fails you and exactly the places where your agent needs to be right.

Byte-perfect round-trip recall for structural artifacts is a hard guarantee, not a statistical property.

Memory artifacts, the decisions and context you've recorded, go through a different path. They're stored with structure: timestamps, salience weights, relationships to symbols and sessions. Recall is deterministic given the same query and state. You can inspect what Fabric knows and why it surfaced what it did.

The Timing

Multi-agent development isn't coming. It's here. If you're already using Claude alongside Cursor alongside anything else, you're already doing it. You're just absorbing the coordination cost yourself.

The MCP ecosystem is early enough that getting familiar with it now puts you ahead. Fabric is built on MCP by design, not as an adapter bolted on later, but as the native interface. That means as more agents adopt MCP, Fabric becomes more useful without you doing anything.

The structural index approach also means Fabric works on real codebases: the kind that have accrued complexity over time, where a text-similarity search returns the wrong things and a model that doesn't understand your architecture will mislead you. If you've built something real, you need something that understands it structurally.

Install Tonight

The gap between what AI coding agents could do and what they actually do for your specific codebase is mostly a context problem. Fix the context, and the agents get dramatically more useful.

Fabric closes that gap. One install, five minutes, and by tomorrow morning your agents will know your codebase the way you do: structurally, persistently, and without you having to repeat yourself again.

Sign up free at cognisos.ai and run the quickstart. The structural index will be live before you finish your next cup of coffee.