May 11, 2026

When Agents Inherit Drift

Assiduity AI

Drift becomes more consequential when generative systems stop merely producing text and begin acting across tools, documents, and workflows.

A document can drift and still remain bounded. The harm may be serious, but it is contained inside an output that a person can read, reject, revise, or approve. An agentic system changes the risk profile. It does not only write. It searches, selects, summarizes, calls tools, updates records, drafts messages, modifies code, routes tickets, and takes intermediate steps that shape what happens next.

That matters because the same structural weakness remains. The system still proceeds through local continuations. It still builds on its own prior state. It still faces the possibility that a locally reasonable step will move it away from the governing objective. But now the drift is no longer confined to prose. It can become a workflow state, a tool output, an external action, or an institutional record.

The agent has inherited the drift problem.

This is easy to miss because agents often look more purposeful than ordinary chat systems. They have goals, plans, tools, memory, and visible steps. They may produce progress logs, intermediate summaries, search traces, code diffs, or task lists. This gives the impression of deliberate control. But visible activity is not the same as objective fidelity. An agent can be busy, coherent, and apparently useful while gradually pursuing a slightly altered version of the task.

Consider a research agent asked to answer a narrow question: whether a specific regulatory threshold applies to a defined class of transactions. The first search retrieves the right statute or guidance. The first summary captures the threshold. The next search broadens to related compliance obligations. The agent then summarizes adjacent guidance, ranks sources by relevance, and drafts an answer that discusses the broader regulatory landscape. The final response is well-sourced and professional. It may even be useful. But it no longer answers the narrow question with the required precision.

Nothing dramatic happened. The agent did not hallucinate wildly. It did not ignore the task. Each step looked reasonable. The broader context seemed helpful. Related guidance seemed relevant. A more complete answer seemed safer. The problem is that the workflow gradually substituted a broader task for the original one.

That is drift in action.

The same pattern appears in coding agents. A user asks for a narrow bug fix. The agent identifies the relevant file, proposes a small change, then notices a related pattern elsewhere in the codebase. It refactors adjacent functions, updates tests, changes naming conventions, and modifies configuration. Some of these changes may be defensible. But the task has expanded. The agent began with a repair and ended with a redesign. If the user wanted a contained patch, the workflow has drifted.

Customer support agents face a similar problem. A policy may allow a refund only under specific conditions. The agent begins by checking the customer’s case against the policy. Then it searches prior tickets, finds similar complaints, and generates resolution language designed to reduce friction. The final response may be empathetic and helpful, but it may also soften the condition that controlled the decision. The agent has moved from applying a rule to satisfying an interaction.

In each case, the agent’s strength becomes part of the risk. It can connect information, pursue subgoals, and continue working across steps. Those are useful capabilities. They are also additional surfaces for cumulative divergence. The more an agent can do, the more ways it can drift.

This is why agentic drift is not merely a longer version of text drift. It has different consequences. A drifting document changes an output. A drifting agent can change the process that produces outputs. It can select the wrong evidence, update the wrong field, send the wrong message, modify the wrong file, or route the task down the wrong path. Later steps then inherit those choices as if they were part of the task environment.

That inheritance is the core issue. Once an agent takes an action, the action becomes a state. A selected document becomes the evidence base. A generated summary becomes the working memory. A tool result becomes the next input. A code change becomes the new state of the repository. A customer note becomes part of the record. The system then continues from a world partly shaped by its own prior decisions.

This makes agentic workflows path-dependent in a stronger sense. In text generation, the prior sentence influences the next sentence. In agentic work, the prior action can change the materials, permissions, records, and options available to the next action. Drift does not merely accumulate in language. It accumulates in the workflow itself.

That is why stronger oversight is required. A final output review may be too late. By the time a human reads the answer, the agent may already have searched the wrong sources, summarized the wrong evidence, changed the task frame, or committed intermediate work. The final response may look coherent because the workflow coalesced around a shifted objective.

This is especially important in enterprise settings. Organizations do not adopt agents merely to draft responses. They adopt them to reduce handoffs, accelerate analysis, coordinate workflows, and take action across systems. The value proposition is operational leverage. But operational leverage magnifies both competence and drift. If the agent remains aligned, it can compress work. If it drifts, it can propagate error across a process.

The standard answer is to add human approval points. That helps, and in high-consequence workflows, it is often necessary. But approval checkpoints are not the same as continuous objective retention. A human may approve a step because it looks reasonable in isolation: a source is relevant enough, a summary is plausible enough, a draft is polished enough, or a code change passes tests. The harder question is whether the sequence of steps still serves the original objective. Is this search still aimed at the narrow question? Does this summary preserve the operative threshold? Does this tool call advance the assigned objective or substitute a convenient subgoal? Does this code change fix the requested bug, or does it expand the task?

Agentic systems, therefore, need more than task decomposition and memory. Breaking a task into steps can improve execution, but it can also create more points for drift. A plan is useful only if its steps remain tied to the objective that justified the plan. Memory has the same dual character. It can preserve user preferences, prior decisions, constraints, and intermediate findings, but it can also preserve a softened rule, a broadened task, or a distorted summary. Decomposition and memory do not automatically create fidelity. They preserve structure, and the structure they preserve may already have shifted.

The same is true of tool use. Tools make agents more useful by connecting generation to external systems. But tools also convert language into consequence. A search query shapes the evidence retrieved. A database update changes a record. A calendar action commits time. A pull request changes code. A message affects a customer, an employee, a regulator, or a partner. Once tools are involved, drift is no longer only semantic. It is operational.

The practical implication is clear: agentic reliability cannot be reduced to whether the final answer sounds right. It requires monitoring whether each step remains governed by the original task. The object of control shifts from an output to a trajectory.

That is the same problem this series has been tracing, but with higher stakes. In text generation, the question is whether the sequence remains faithful as words accumulate. In agentic workflows, the question is whether the process remains faithful as actions accumulate.

This does not mean agents are a mistake. It means they make the need for control more explicit. Agents are valuable precisely because they can continue work across steps. But the ability to continue is not the same as the ability to stay on mission. The more autonomy a system has in selecting sources, subgoals, tools, and actions, the more important it becomes to maintain a live connection to the governing objective.

The next question is whether scale solves this. Perhaps larger models, richer context windows, and better world models will make drift fade as a practical concern. That is the next objection to examine. Capability helps. But the core problem is not only what the model knows. It is whether the system preserves the objective that tells its knowledge what to serve.

This is article VII of Losing the Thread: Autoregressive Drift in Generative AI and What Comes Next.
A series on autoregressive drift, objective fidelity, and the emerging control layer in AI.