What is agentic entropy?

Agentic entropy, defined precisely

The paper’s definition: a process-level drift whereby autonomous updates optimize for local correctness while eroding global design intent. Traditional code-diff review cannot catch it because diffs address local outputs, not global agentic behavior. The planning steps, tool-call sequences, cross-file decisions, and contextual inferences that guide an agent’s actions stay largely hidden from human supervisors while the visible output keeps passing its checks.

Agentic entropy unfolds across runs and environments: agents repeatedly operate with limited systemic awareness, compounding small misalignments that no single diff ever shows. A visible manifestation is agentic technical debt — the accumulated structural misalignments, duplicated logic, and fragile refactoring that emerge when entropy goes unchecked. The resulting codebase suffers a stability gap: locally functional code that lacks the systemic robustness long-term evolution needs.

And the entropy loop closes through people. Agentic entropy co-evolves with cognitive debt, the progressive erosion of the developer’s or reviewer’s system-level mental model as autonomous actions outpace comprehension. As cognitive debt accumulates, the human’s capacity to detect the next round of drift shrinks — undetected drift begets further structural misalignment, and humans end up procedurally in the loop yet progressively less able to govern the system.

The three failure modes

Accelerating factors compound all three: prompt sprawl (rules accreting in system prompts until none are reliably followed) and stochastic effects (the same prompt producing different drift on different runs) mean entropy accumulates even on teams doing everything else right.

Why the diff cannot save you

Diff-based review inspects the outcome of agentic activity. It reveals nothing about the process that produced the outcome — which is exactly where the drift lives. Two profiles make the paper’s case. Lay users vibe coding gain structural visibility that functional success otherwise masks: the app works, so nothing prompts them to look at how the pieces now fit together. Professional developers get richer contextual grounding for review without more overhead — but only if the review surface shows the process, not just the product.

The human side has its own vocabulary now: cognitive debt is the gap between how much code exists and how much any human genuinely understands; cognitive surrender is the moment the team stops trying to hold that model at all. Entropy is the code-side process, debt is the mind-side outcome, and each feeds the other.

What actually controls it

The paper’s answer is process-oriented explainability built on three pillars: conformity seeding (anchor every agent run to the architectural intent it is supposed to preserve), reasoning monitoring (expose how decisions unfold across time, tool calls, and architectural boundaries), and a causal graph interface that renders intent-level telemetry alongside the code. The point is not to replace code review — it is to give review a memory of the why.

In practice, teams converge on a working version of this without the framework: keep intent documents next to the code the agent edits, review trajectories rather than only diffs, and insist on an append-only, replayable record of what the agent actually did — which is precisely where the 2026 harness generation went. DeepSeek’s open-source agent harness made the append-only session log its architectural center: resume, fork, and replay are all projections over one ordered event stream, so the process is inspectable after the fact by default.

VibeFuse takes the same idea to the working surface: every agent, tool, and CLI runs as a widget on one canvas, so the planning steps and cross-file decisions stop hiding inside one tool’s scrollback — you see the loop, not just the output. It is the first ever free widget-based AI harness, runs locally, and its open-source marketplace pays creators 80% revenue share for the widgets, skills, and styling packs that make oversight cheap. Pair it with VocalFuse for local dictation while you review.

Related evidence pages

The visible outcome: vibe slop. The human cost: vibing fatigue. The verdict: is vibe coding bad. The security deep-dive: is vibe coding secure. The discipline: harness engineering.