The next step is making intent an enforceable boundary, not merely another score.
The pull request was designed for a world in which a human wrote the code, understood the path taken to produce it, and asked another human to inspect the result. Coding agents are breaking that model.
An agent can explore a repository, try several implementations, reverse earlier decisions, modify multiple services, ask subagents for help, and produce more code than a reviewer can realistically reconstruct from the final diff. Review agents then add another layer of comments, findings, scores, and suggested fixes. The pull request slowly turns into an audit log that agents can process more easily than the humans expected to approve the change.
Entire’s newly launched Git forge takes that problem seriously. Its Trails replace the conventional pull-request view with a workspace that keeps the goal, agent sessions, decisions, code changes, findings, CI results, and approvals together. Trails can span repositories, and review agents evaluate every push for signals such as security risk, code quality, and intent drift. Gates determine whether open findings, failed checks, or missing human approvals should prevent a merge. Entire
This is an important shift. The unit of review is moving from the code change to the history of how the change came into existence.
At ArmorIQ, that direction feels familiar. In our earlier post, Claude.md Is Brilliant. It Also Reveals the Next Control Problem for AI-Native Software Engineering, we argued that as developers increasingly express objectives while agents determine implementation, intent begins to look more like the primary engineering artifact. Git can show the diff. The terminal can show the commands. CI can tell us whether the tests passed. None of them, by themselves, establish whether the agent’s evolving reasoning remained faithful to what the developer actually wanted.
Entire is right that the old review surface is no longer enough. But preserving the trail introduces a second question: What, inside that trail, is authoritative?
A history of decisions is not yet a boundary
A Trail can preserve the original request, the agent’s sessions, intermediate decisions, reviewer feedback, and the resulting code. That context is valuable. Without it, reviewers are left staring at implementation choices whose rationale disappeared with the coding session. But provenance and authority are not the same thing.
A transcript tells us what the agent saw and how its plan evolved. It does not automatically tell us which parts of that context were allowed to redefine the task. A coding agent may consume issue descriptions, design documents, repository instructions, code comments, test output, error logs, MCP responses, reviewer findings, and messages produced by other agents. All of these can legitimately influence the implementation. They do not all carry equal authority to change the objective.
We made this distinction in Now, Everyone Is Talking About Intent. At ArmorIQ, intent is not simply the initial prompt, the latest plan, or the current reasoning trace. It is the invariant that should survive as the agent discovers information and refines its approach. Plans should change. Strategies should improve. The purpose that justified the work should not silently mutate with them.
This matters because agent context can be contaminated. OpenAI’s work on self-replicating prompt injections showed that hostile instructions can travel through files, code comments, email, and multi-agent workflows. Once an agent copies an instruction into an internal artifact, a later agent may encounter it in a context that appears more trustworthy than the original source. In our analysis of those results, we described the core problem this way: context may shape the plan, but it must not mint permission. A continuous memory system could preserve such a compromised sequence perfectly.
The Trail might explain exactly why the agent made the change. It would not, by preservation alone, establish that the change belonged to the objective.
Intent drift should be more than a review score
Entire includes intent drift as one of the signals that can be evaluated on each push. That is a meaningful recognition that code quality cannot be reduced to whether the implementation compiles or passes tests. A change can be technically sound and still solve the wrong problem. Entire
But intent drift raises a deeper engineering question. Is drift something we measure after the agent pushes the code, or something we control while the agent is producing it?
A score is useful evidence. It can tell a reviewer that the latest implementation appears farther from the original goal than the previous one. It can trigger another agent loop or block a merge through a gate. Some forms of drift, however, should not wait for the next push.
Suppose a coding agent is asked to repair an authentication regression. During the work, it decides to read unrelated production credentials, connect to a live service, disable a security check, or delegate the task to an agent with broader authority.
The final diff may never reveal the entire path. Even when it does, the consequential action has already happened. Review therefore needs two complementary layers. The first asks whether the resulting code satisfies the objective. The second asks whether the agent remained inside the authority justified by that objective while producing the code.
Trails create a much richer place to present both forms of evidence. But the second guarantee cannot come entirely from another model reviewing the first model’s output after the fact. It requires an independent control path.
From recorded intent to committed intent
This is where the ArmorIQ approach extends the idea of a Trail. At the beginning of a coding task, the developer’s objective can be captured as more than session metadata. It can become a committed intent boundary.
The agent remains free to explore implementations within that boundary. It can identify files, revise its plan, run tests, delegate bounded subtasks, and respond to new information. When the developer legitimately changes the objective, that change becomes an explicit trust update rather than an accidental consequence of a long conversation.
The key distinction is subtle: A Trail records how the objective was interpreted. Intent assurance governs which interpretations may become authorized execution. That turns the history from passive provenance into evidence connected to a control decision.
ArmorIQ’s Intent Assurance Plane binds the accepted plan to subsequent actions. In the current SDK model, the agent produces a plan, that plan is committed as an intent token, and each tool call is checked against it before execution. An action that does not belong to the committed plan does not simply become another event for later review. It can be stopped before it occurs.
For an agentic coding workflow, this means the eventual Trail could contain more than prompts, code changes, and reviewer scores. It shows that the objective was committed, that a plan refinement remained inside the authorized scope, that a new capability required approval, that one tool call was held, and that another was blocked because it did not belong to the task.
The review surface then answers both halves of the trust question: Did the code match the objective? And did the execution remain authorized while creating it?
The diff is only the last effect
Tool-level verification still does not cover the whole coding environment. A coding agent invokes a shell. The shell launches Python. Python starts another process. That process reads files, opens sockets, modifies the repository, or reaches another service. At the review layer, all of that may eventually collapse into a code diff. At the machine layer, those are concrete effects that occurred long before the reviewer saw the change.
This is why our earlier From Objective to Syscall work followed intent below the tool boundary. The argument was that if intent exists only at the agent gateway, it disappears when execution becomes a process tree. ArmorIQ’s Kernel Assurance Plane carries objective-derived authority into the runtime so file, process, and network effects can remain governed even after the action leaves the original agent interface.
This does not mean every coding rule belongs in the kernel. It means the review system should be honest about where a guarantee comes from. A review agent can judge whether an architectural choice seems consistent with the task. A deterministic test can verify an invariant. A policy layer can decide whether a requested tool call belongs to the plan. A sandbox or kernel boundary can prevent access to resources the task was never authorized to touch.
All of those signals can appear in the same Trail. They should not be mistaken for equivalent evidence.
The Trail can become a control-plane view
The most interesting possibility is therefore not merely replacing the pull request with a better dashboard. It is using the Trail as a human-readable view over the entire objective lifecycle.
The developer begins with a goal. The agent refines that goal into a plan and implementation. Independent controls verify that the refinements remain within scope. Runtime enforcement constrains the effects produced during the work. Review agents inspect qualities that require semantic judgment. Deterministic checks verify properties that should not depend on model opinion.
Human reviewers focus on unresolved intent questions, consequential exceptions, and decisions that genuinely require organizational judgment. The Trail then becomes the place where those forms of evidence converge. Not a transcript humans are expected to reread from beginning to end. Not a collection of scores that turn green after enough agent loops. A compact explanation of whether the work is faithful, safe, and ready to merge, with the underlying lineage available when someone needs to inspect it.
That is a much better use of human attention than asking a senior engineer to reconstruct an autonomous coding session from thousands of changed lines.
Agentic code review is becoming intent review
Entire’s central insight is right: the pull request was built around the wrong unit of work for agentic software development. When humans wrote most of the code, the diff was a reasonable proxy for the engineering process.
When agents write the implementation, the diff is only the final artifact of a much larger sequence of decisions. The industry response cannot simply be to point more agents at that diff. The review boundary has to move upward toward the objective and downward toward the effects. Upward, because reviewers need to know why the change exists and whether the implementation remained faithful to that purpose. Downward, because some boundaries must be enforced while the agent is acting, not discovered after the code is ready to merge.
We have been approaching those two directions through intent assurance and runtime enforcement. Entire’s Trails provide a compelling surface where that evidence could become understandable to developers.
The combination points toward a different software-development lifecycle. Humans define objectives and make the decisions that require judgment. Agents generate and refine implementations. Independent controls preserve the objective’s authority through the work. The forge records the lineage and presents the evidence required to ship with confidence.
The pull request asked:
What code changed?
The Trail asks:
How did this change come to exist?
The next control plane has to answer one more question:
Did every consequential decision still belong to the objective we authorized?
That is when agentic code review stops being a faster version of yesterday’s process.
It becomes intent assurance for software engineering.



