Why the obvious builds break
Haven't we already built this? Doesn't search cover it? And why does it matter now? Here are the answers, with the sources.
Wiring context into your agents is the easy part - every team is building that, and ours is open source. The hard part is the record underneath: what your org actually decided, across every tool, kept current - so an agent can tell what still stands from what got walked back, and why. That's the intent layer.
You've probably already tried this.
A lot of teams we talk to are building this in-house right now - a second brain over docs, chat and tickets. The builds work, until the same wall: nothing tells them which answer is still current. Here's why each one breaks - and what's actually different.
A RAG bot over your docs
It only finds decisions someone already wrote down. The ones that matter most - made in a Slack thread, a meeting, a PR review - never made it to a doc. The bot can't retrieve what was never written.
A CLAUDE.md (or rules file) per repo
Great for one repo's conventions. Blind to the decision another team made in their repo three months ago that yours now contradicts. It doesn't know what it doesn't contain.
Search across all your tools
An enterprise search index returns both sides of a settled debate and ranks them by relevance, not by which one still holds. You still can't tell what was superseded or what conflicts. Search finds documents; it doesn't resolve decisions.
A vector store of your own
The instinct most teams have. But a vector DB ranks chunks by similarity, not by which decision is current or authoritative - and it only answers when asked. The hard part was never storage. It's capturing decisions across a dozen tools, resolving which supersede which, and flagging the conflict before you ship.
Your own MCP tools
The build most agent-forward teams reach for now - and the tools work. That layer is the easy part, which is why ours is open source and the CLI tier is free. The unpriced part is the maintenance contract: when a decision changes in a thread next month, who updates what the tools serve? Nothing in the pipe knows an answer went stale, and nothing tells your agent when two answers disagree.
ADRs plus a nightly review agent
The most mature version we meet: an agent reviews every merge request against your ADRs overnight. It works exactly as well as your ADRs are up to date. It can't see the decision that never became one, and it can't tell a live ADR from a superseded one. Align feeds them - decisions captured where they happen, resolved for what still stands, ready for your ADRs to draw from.
Align captures decisions from the conversation before they're ever written down, then links and resolves them - so when you or your agent ask, you get one answer: what still stands, who decided it, and why. And because every one of these alternatives waits to be queried, Align also surfaces the conflict before you ship, whether or not anyone thought to ask.
Similarity search cannot tell you what is still true.
The obvious build is embeddings over your own history. Here is what happens next. Each source is named on its own card.
Most information retrieval models (including SOTA ones) do not consider negation, performing the same or worse than a random ranking.
A model that cannot see negation cannot tell "we are doing this" from "we are not doing this". Those are the two sentences a decision record exists to keep apart.
The bottleneck is not code review. It is not even architectural decision-making. The bottleneck is context transfer. That context lives in people's heads, in Slack threads from 2023, in design docs that were never updated.
A company at scale reporting the problem, not a vendor selling the answer. The limit their production agent hit was organisational memory, not model capability.
A contradicting decision scored 0.31. An agreeing one scored 0.38. The contradiction ranked lower, which is backwards.
Embeddings measure what a decision is about, never whether it agrees. That is why Align adjudicates a verdict against the record instead of ranking by similarity and hoping.
How we hold ourselves to that
Our conflict classifier is held to a hand-labelled gold set of 183 decision pairs, each one read and labelled by a person. Every pull request replays the classifier's deterministic rules against it as a ratchet, so a change that quietly makes detection worse fails the build.
And we pre-registered the reliability study on our own relationship taxonomy: the sample, the collapse map and the decision rule were frozen and committed before any label was collected, so the method could not be tuned once the answers were visible.
We are not publishing results from it yet. The pilot was labelled by models from one family, which cannot fairly judge its own output, so the figures wait on a human pass. Publishing the protocol before the numbers is the whole point of pre-registering it.
AI made decision context operationally critical.
For thirty years the bottleneck was writing the software. Then, quite suddenly, writing the code stopped being the slow part - and what was left was deciding what to build and why. That work still happens at human speed, in meetings and threads, and mostly goes unrecorded.
So the cost of an agent acting on the wrong decision is no longer a confused afternoon, it's merged code. The teams getting this right are building the decision layer now.
Your agents have everything except what your team actually decided.
Code, docs, and APIs are already structured and queryable. The reasoning behind every engineering decision is not - and it's the one input an agent can't see.
Other context layers return one clean answer, ranked by relevance or freshness - and similar isn't the same as still true. Align keeps the disagreement - a typed conflict in the graph, raised even when nobody thought to ask, with a verdict and its source instead of a similarity score.
Align is that one place, for the decisions: deterministic context for probabilistic agents.
"You can outsource your thinking but you can't outsource your understanding."
Andrej Karpathy, Dec 2025
It doesn't invent a decision that nobody made.
Three people talk, two agree, nobody lands it. Align says so: it separates the decision it can evidence from the question still open.
Consensus really is subjective, and that is the point. If Align pretended every thread reached it, you'd stop trusting the ones that did.
Still think you can build it?
You probably can. The tools layer is the easy part, which is why ours is open source and the CLI is free. Install it and see what your own history looks like, or book 30 minutes and we'll go through it together.