AI coding agents read your code perfectly and understand your team not at all. So they produce diffs that look clean, pass a quick review, and quietly undo something that was there on purpose: a guard rail, an invariant, a workaround that exists because the team hit a problem once and swore never to repeat it. Nothing in the code explained why that line mattered, so the agent optimized it away.
The code is usually fine. The context is what's missing. And this isn't really an AI problem, it's a memory problem that AI just made impossible to ignore.
Two knowledge layers, and agents only see one
Every engineering org runs on two layers of knowledge.
The explicit layer is code, READMEs, tickets, merge history. It's written down, and agents read it fine.
The tacit layer is everything else. Why a design was chosen over the obvious alternative. What the team tried before and abandoned. Which invariants must never break. Which shortcut is quietly forbidden and why. Who to ask before touching the fragile part of the system. None of that is written down anywhere clean. It lives in Slack threads, in PR review comments, and in the heads of a few long-tenured engineers.
A senior engineer's real value isn't typing speed. It's that they carry that second layer around in their head. They start a task already knowing that a certain approach deadlocked in production last year, that a pattern is banned for a security reason, and that you don't touch payments code without a heads-up. AI agents start every task with none of it.
We built Decispher to capture that second layer and serve it back, to humans and agents both, as a queryable system of record.
The mental model
Here's the line that made it click for me:
Git stores what changed. Decispher stores why it changed, what must not change, what was tried before, and what the next engineer should know before touching it.
Everything below is in service of that.
Capture: harvest context from where work already happens
The fastest way to kill a knowledge system is to make engineers maintain it by hand. Nobody does. So capture is passive. Slack bots listen in channels, GitHub webhooks watch PRs and reviews, the Jira app reads tickets and comment threads, and Branch Story records what happens inside coding sessions.
Engineers keep writing normal messages and normal PR descriptions. Decispher extracts the durable signal from them and sorts it into seven structured types. The structure matters because each type should change what an agent does:
| Type | What it is | What it should do to an agent |
|---|---|---|
| Decision | A choice the team made | Inform |
| Convention | A recurring rule | Shape generated code |
| Constraint | A hard boundary | Block the action |
| Rationale | The reasoning behind a choice | Explain intent |
| History | What was tried and failed | Prevent the dead end |
| Ownership | Who owns an area | Route the question |
| Plan | Approved-but-not-built intent | Set expectations |
A pile of undifferentiated message text can't do this. Blocking an action and shaping generated code are different operations, so the memory that drives them has to be typed.
Fuse: one decision, not three copies
The same architectural rule shows up in five places with slightly different wording: a Slack thread, a PR comment, a line in a Jira ticket. Store all five and you haven't built memory, you've built noise with extra steps.
The Context Fusion Engine merges those fragments into one canonical unit using semantic similarity, explicit references, timing, and overlapping people and entities. Then it links units into a graph with real relationships: confirms, extends, contradicts, supersedes, same-topic, derived-from. When two units can't both be true, it flags the contradiction instead of silently keeping both.
That graph turned out to be the closest thing to how a senior engineer actually reasons. They don't recall isolated facts, they recall chains. An authentication choice constrains a deployment pattern, which affects caching, which touches compliance. The graph encodes exactly those chains.
Serve: give the agent the right context, not all of it
The lazy way to give an agent context is to shove a giant generic block into every call. It burns tokens, and worse, it buries the one fact that mattered under a thousand that didn't.
Decispher splits it in two. A small, always-loaded Context Map is committed to .decispher/ in the repo as the spine. The deeper detail stays in Decispher and is fetched live over MCP, only when a task needs it.
So an agent can ask focused questions mid-task instead of hoping it read the right static file. The tool that changes the most behavior is check_intent. The agent describes what it's about to do and gets a verdict before writing code. Illustratively:
> check_intent("remove the token-rotation step to simplify the session flow")
BLOCKED
Violates a CONSTRAINT: token rotation must not be removed from the
session flow.
Rationale: it was added deliberately after a past security issue.
Owner: the payments team.
Sources: the Slack thread and PR where the rule was set.
Instead of confidently deleting something load-bearing and finding out in review, or in production, the agent finds out first.
Because context should reach agents in the format they already read, Decispher also generates CLAUDE.md, .cursorrules, and AGENTS.md, and keeps them in sync through pull requests when the underlying context changes.
Enforce: an automated reviewer that remembers
Capture and serving help before and during work. Lens helps at review time. It reads a PR against the knowledge graph and flags decision violations, convention drift, and constraint breaches by analyzing intent, not by matching patterns. When it comments, it explains which governing decision the change violates and why that decision exists.
That's the senior-engineer move that's hardest to scale: recognizing that a perfectly reasonable-looking change breaks a rule the team agreed on months ago.
If you want the formal version of this, our open-source entry point is Decision Guardian, which enforces Architectural Decision Records on PRs. It's the front door. The platform grows from there into automatic capture, live serving, and semantic review.
Humans use the same memory
This isn't an agent-only tool, and that's deliberate. Engineers get search, Ask Decispher, dashboard chat, Slack commands, and PR-comment answers, all backed by the same graph. The operating rule is no source, no claim. Every answer cites the units it came from.
The point of one shared memory is alignment. When a new hire asks why the team does auth a certain way, and an agent asks the same question, they should get the same cited, traceable answer. Two separate memory systems drift apart. One system of record keeps everyone pointed at the same truth.
Branch Story: the flight recorder for coding sessions
This is the feature I'm most attached to. Branch Story keeps branch-level memory. It opens a session with a pre-flight briefing, records discoveries in the background, offers a Story Mode replay of how the branch evolved, warns you through déjà -vu detection when you're re-attempting an approach that was already abandoned, and lets you promote a hard-won lesson into the main knowledge base with one click.
It preserves the thing that normally evaporates between sessions: not just the final decision, but the sequence of attempts, reversals, and open questions. That's the actual texture of senior-engineer context.
On privacy, briefly
A memory layer is only adoptable if it isn't a liability. Raw Slack text isn't stored. Messages hit a queue worker, structured units get extracted, and the raw text is discarded. Branch Story keeps raw session data only briefly and purges it after merge. What survives is the decisions, constraints, and lessons, not the transcript.
What I actually believe after building this
The wrong way to see Decispher is as a fancier wiki, a place you go to read. The right way is as organizational memory that shapes code generation, review, and onboarding at the moment of work, reaching into the workflow to say "wait, not like that, and here's why."
AI didn't create the tacit-knowledge problem. It just removed our ability to keep ignoring it, because now we have tireless contributors writing confident code with zero institutional memory. The fix was never a smarter model. It's giving the model, and the humans next to it, the scars, guardrails, and reasoning that used to live in one person's head and leave the day they did.
If your agents keep making context-blind mistakes, that's the gap. It's worth closing.
Decispher is a system of record for engineering decisions. If this resonated, the open-source Decision Guardian is the easiest place to start. You can find smarter version at Decispher's Website
Top comments (0)