Intent debt. The gap between what a system is supposed to preserve and what its AI agents are actually constrained to follow. When agents become the execution layer, undocumented, stale, or unenforced architectural decisions do not just slow delivery — they actively accumulate as structural liability.
Concepts 7 min read · May 2026

# Intent Debt

Most architectural intent inside a team is undocumented, stale, or unenforced. Human reviewers used to compensate for that by carrying intent in their heads and applying it during review. AI agents do not carry that intent and do not wait for review. The deficit was always there. Agents make it load-bearing.

By Theo Valmis · Published May 2026

## 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:

1. Compile. ADRs, operating constraints, and architectural rules are parsed into structured decisions with explicit scope, type, and precedence metadata.
2. Retrieve. When an agent signals intent to write code, the governance layer retrieves the decisions that apply to the target file, package, or operation.
3. 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.

## Further reading

- AI-Native Engineering Has an Intent Debt Problem

## Frequently asked questions

What is intent debt?
Intent debt is the gap between what a system is supposed to preserve and what its AI agents are actually constrained to follow. When architectural decisions, constraints, and operating rules exist in documents or human memory but are not compiled into a form agents must query before generating code, that gap is intent debt. It accumulates silently and compounds as agent velocity increases.
How is intent debt different from technical debt?
Technical debt describes implementation quality — shortcuts, workarounds, code that works but is hard to maintain. Intent debt describes a constraint gap — the difference between what the system is supposed to do and what its agents are actually enforced to do. You can have zero technical debt and high intent debt if your agents are writing clean, well-structured code that violates every architectural decision the team has ever made.
Why does intent debt accumulate faster with AI agents?
Because AI agents generate code at a rate human reviewers cannot match. In human-paced delivery, intent lived in engineers' heads and was transmitted through pair programming, code review, and conversation. At agent velocity, that transmission channel saturates. Agents write more code, faster, with less knowledge of prior decisions. Intent debt is the structural deficit that emerges when the delivery rate exceeds the rate at which intent is enforced.
Why don't code review, memory systems, or orchestration solve intent debt?
Code review is reactive — it catches violations after code is written, not before. At agent velocity, the review queue grows faster than reviewers can drain it. Memory systems (RAG, vector stores, context injection) optimize for retrieval, not enforcement — they surface relevant content but cannot deterministically block a violation. Orchestration systems coordinate agent execution but do not compile decisions into enforced constraints. All three are advisory at the point of generation; intent debt requires enforcement before generation.
How does governance infrastructure reduce intent debt?
By compiling architectural decisions into a typed, scoped, precedence-aware corpus that every agent must query before generating code. Governance infrastructure closes the intent debt gap at the point of generation: the agent asks what constraints apply here, receives a deterministic answer, and writes code that satisfies them. The gap between what the system is supposed to preserve and what agents are constrained to follow approaches zero when the constraint is live, current, and enforced.
Related governance concepts

- Governance Infrastructure

  The platform layer that compiles decisions into enforced constraints — the mechanism that closes the intent debt gap.

- Governance Before Generation

  The enforcement posture that addresses intent debt at the point of intent rather than at the point of review.

- AI Agent Drift

  The agent-side phenomenon — sessions diverging from decisions they were never bound to. Intent debt is the constraint gap; agent drift is what fills it.

- Architectural Drift

  The codebase-side residue left behind when intent debt is paid in agent output rather than enforcement.