Definition
Intent debt is the gap between what a system is supposed to preserve and what its AI agents are actually constrained to follow.
The debt accumulates whenever architectural decisions, operating constraints, or design rules exist in documents, wikis, or human memory but have not been compiled into a form that agents must query before generating code. The decisions exist. The enforcement does not.
Intent debt is structural, not behavioral. It is a missing layer between the decisions a team has made and the constraints its agents operate under — not a failure of any individual agent, ADR, or engineer.
Why it emerges in AI-native engineering
Intent debt is not new. Every team has carried it. What changed is who was absorbing it.
In human-paced delivery, senior engineers and reviewers carried the missing intent in their heads and applied it during pair programming, design discussions, and code review. The decisions did not need to be compiled into a queryable form because a human with context was already in the loop. The buffer hid the debt. From the outside, the system looked governed; from the inside, the governance lived in people's memories.
AI agents change two things at once. They generate code faster than human reviewers can inspect — and they have no inherited memory of decisions made in prior sessions, by other agents, or by other developers. Each agent session begins from whatever it can observe in the workspace. If the workspace does not make decisions queryable, the agent infers. The inference is often plausible. It is rarely authoritative.
The human buffer that was silently doing enforcement does not scale with agent output. Intent debt is what accumulates when that buffer collapses and nothing structural takes its place.
How intent debt differs from technical debt and cognitive debt
| Debt type | What it names | Primary consequence |
|---|---|---|
| Technical debt | Implementation shortcuts that cost future maintainability | Code that works but is hard to change |
| Cognitive debt | Decisions not documented for human knowledge transfer | Engineering time lost to rediscovery |
| Intent debt | Constraints not compiled into machine-enforceable form | Agent-generated code that violates architectural decisions |
The distinctions matter for remediation. Technical debt is addressed by refactoring. Cognitive debt is addressed by documentation. Intent debt is addressed by neither — it requires compiling decisions into a form that closes the enforcement gap before the agent writes.
A team can have zero technical debt and still carry high intent debt — if its agents are writing clean, well-structured code that quietly violates the architectural decisions the team has made. Clean code is not governed code. The two questions answer different things.
This is also why excellent documentation does not retire intent debt. Documentation serves the human knowledge transfer channel; intent debt lives in the machine enforcement channel. ADRs read by a person at 2pm do not constrain an agent writing code at 2:03.
Why review, memory, and orchestration are insufficient
Three approaches are commonly proposed for the problem intent debt names. None of them close the gap at the point where it matters.
Code review is reactive. It catches violations after the code exists, not before. At human delivery pace this is acceptable — review keeps up with generation. At agent velocity the generation cycle runs orders of magnitude faster than the review cycle, and review becomes a queue that cannot be drained, not a control.
Memory systems — RAG, vector stores, context injection — optimize for retrieval, not enforcement. They surface relevant content when queried. They do not guarantee that the surfaced content is current, that it takes precedence over conflicting signals, or that the agent is bound to follow it. Surfacing an ADR in context does not prevent an agent from ignoring it. Retrieval and constraint are different operations.
Orchestration coordinates agent execution — sequencing, routing, tool access. It controls when an agent runs and what tools it can call, but it does not compile decisions into binding constraints. Orchestration governs the workflow around the agent; intent debt lives inside what the agent writes.
The common failure mode is to treat advisory mechanisms as if they were enforced. Review, memory, and orchestration are all post-generation or non-binding at the moment of writing. Closing the gap requires a mechanism that is queried before generation and returns a deterministic answer.
How governance infrastructure reduces intent debt
Governance infrastructure addresses intent debt by compiling architectural decisions into a typed, scoped, precedence-aware corpus — and by enforcing that corpus at the pre-generation hook. The mechanism is:
- Compile. ADRs, operating constraints, and architectural rules are parsed into structured decisions with explicit scope, type, and precedence metadata.
- Retrieve. When an agent signals intent to write code, the governance layer retrieves the decisions that apply to the target file, package, or operation.
- Enforce. The decisions are presented as constraints the agent must satisfy, not suggestions it may consider. Violations are blocked or flagged with a citable verdict.
When this loop is in place, intent debt cannot accumulate silently. The gap between what the system is supposed to preserve and what agents are constrained to follow is closed at the point of generation. The demo walks through this loop end-to-end — the agent proposes a violation, the corpus blocks it, the retry comes back compliant. Decisions that are compiled, current, and scoped are enforced in every session, by every agent, without depending on review to catch violations after the fact.
Intent debt is not eliminated permanently. New decisions create new opportunities for the gap to reopen if they are not compiled. Governance infrastructure is a practice, not a one-time fix — but it is the only mechanism that operates in the machine enforcement channel where intent debt actually lives.
How to know you have intent debt
Intent debt is invisible until it is measured. Most teams discover they have it the same way they discover technical debt: through symptoms that compound until they cannot be ignored. These patterns recur across the use cases where teams adopt Mneme — recognizable signs include:
- Reviewers keep correcting the same pattern. The decision exists, the agents do not know it, and review becomes the enforcement layer by default — a layer that does not scale.
- Two services solve the same problem differently. The team picked an approach; the agent in the second session never queried it.
- An ADR is "live" but nothing changes after it lands. Documents are written. The generation behavior does not move because nothing binds the agent to the document.
- New engineers re-derive decisions that already exist. The decisions live in heads, not in a queryable form — so the agent and the new engineer face the same gap.
- "AI velocity" feels indistinguishable from "AI churn." Throughput is high. Coherence is not. Output rate without an enforcement layer is the surface signature of intent debt.
The diagnostic is simple: pick a recent architectural decision. Ask whether any agent on the team is bound to follow it, or whether a human has to catch the violation. If the answer is "a human catches it," that decision is denominated in intent debt. A pilot compiles your existing ADRs into the enforcement layer and measures the gap directly.