Most “Agents” Are Workflows in a Trench Coat

Part 1 of The Agency Problem

Every few months the tech industry finds a new word to abuse until it collapses under the weight of investor enthusiasm and product-page perfume. “Agent” is the current victim.

Somewhere along the way, a prompt wrapped around a tool call, a retry loop, and a little state management got promoted from software pattern to synthetic co-worker. Founders rejoiced. Decks were updated. Landing pages began speaking in hushed reverence about autonomy. And the rest of us were invited to pretend that a workflow wearing a fake mustache had crossed the threshold into digital personhood.

This is not a complaint about usefulness. Usefulness matters. A lot of these systems are good at what they do. They summarize, route, draft, and retrieve, and occasionally rescue people from the administrative sewage flood of modern work. Useful systems deserve respect.

But usefulness is not agency.

That distinction matters more than the current AI conversation seems willing to admit. As of early 2026, the word “agent” is being stretched across such a wide range of systems that it has started to lose explanatory value altogether. A chatbot with access to a calendar becomes an agent. A workflow engine with a language model in the middle becomes an agent. A scripted orchestration pipeline that calls three APIs and writes to a database becomes an agent. At this rate, a vending machine with a plugin architecture will be keynote material by autumn.

The problem is not just semantic. Bad language produces bad thinking. If we blur the line between a reactive assistant, a structured workflow, and a system that can actually pursue goals across time under changing conditions, then we start designing badly, evaluating badly, and governing badly. We fund theater. We mistake fluency for autonomy. We build mythology where architecture should be.

So before the term “agent” gets turned into the kind of corporate incense that can bless absolutely anything, it is worth drawing a few distinctions.

A Working Taxonomy

The AI research community has not been careless with the word. Stuart Russell and Peter Norvig, in the textbook that has defined the field for three decades, describe agents as systems that “operate autonomously, perceive their environment, persist over a prolonged time period, adapt to change, and create and pursue goals.” That definition has real teeth. It demands persistence, perception, adaptation, and purpose. It excludes a great deal of what currently wears the label.

A simpler way to map the landscape is to separate four categories that the industry keeps collapsing into one.

A tool does something when invoked. A calculator is a tool. A search function is a tool. A translation model used on demand is a tool. It acts when called and stops when done. No lingering ambition. No continuity of purpose.

An assistant is a different thing: a responsive layer around tools and information. It answers, drafts, suggests, and summarizes. It may call a function or two when asked. It is interactive but mostly reactive, waiting for the human to define the moment and the goal. Hannah Arendt drew a useful distinction between what she called work and action in The Human Condition. Work produces objects within a designed process. Action reveals an agent through choices made under conditions of uncertainty. Assistants, however capable, remain in the territory of work.

A workflow is a structured sequence. It moves through predefined stages toward a bounded outcome. It may branch, retry, escalate, and recover. It can look sophisticated. It can even feel adaptive from the outside. But its basic logic is still choreographed. It does not really persist toward a goal so much as execute a designed process.

An agent, at least in the stronger sense worth caring about, is something more demanding. It must be able to pursue a goal across time, retaining relevant memory and using tools in context, while revising its behavior in response to failure or changing conditions. And its actions must carry consequences that shape what happens next.

Memory gives continuity. Tools give reach. Planning gives direction. Consequence gives weight.

Without those things, you may have a very good system. You may have a profitable system. You may even have a system with a slick demo and a standing ovation at a developer conference. But you do not necessarily have an agent.

The Illusion Problem

This is where the confusion starts. Modern language models are exceptionally good at producing the surface cues that humans associate with intention. They explain their actions. They narrate decisions. They appear to reconsider. They remember enough of the recent conversation to feel coherent. Add a few tools, some state, a loop, and a dashboard, and now the whole contraption starts to feel less like software and more like a junior employee with a tragic need for supervision.

That feeling is powerful. It is also misleading.

Movement is not autonomy. Output is not intention. A loop is not a mind.

The philosopher Daniel Dennett spent decades examining what he called the “intentional stance”: the human habit of attributing beliefs, desires, and goals to any system complex enough that doing so becomes a useful predictive shortcut. We adopt the intentional stance toward a thermostat, a chess program, a pet, a colleague. The strategy works because it often produces accurate predictions, not because the system in question necessarily possesses an inner life. Language models are unusually effective at triggering this stance because language is the native theater of human intention. When a system explains its reasoning in fluent prose, we are predisposed to hear a mind behind the words, regardless of the architecture producing them.

The better a system gets at talking about what it is doing, the easier it becomes to project agency onto it. That projection is one of the central perceptual traps of the current AI moment. We are watching fluent systems generate the performance of will, and because language carries such deep associations with selfhood, we keep mistaking the performance for the thing itself.

Where the Architecture Meets the Brick Wall

I have run into this problem in my own work. My team and I manage a quality review process that audits whether credit transactions are processed correctly. The pipeline has clear stages: random sampling to select who gets reviewed, transaction identification, the audit itself, scoring, deficiency analysis, and reporting. On paper, it is an ideal candidate for AI-driven automation. Each stage has defined inputs and outputs. The logic is sequential. The criteria are documented.

You could wire an AI system through the entire chain and it would look, from the outside, like an agent conducting audits autonomously. But the closer we get to the architecture, the more we recognize how much of the system’s real value depends on judgment calls that resist easy automation: which deficiencies matter most in context, how to weight a pattern of errors differently from a one-time mistake, when a score reveals something about the process rather than the person. The system we are developing is useful. It is structured. It moves through stages efficiently. But it is not pursuing a goal under uncertainty. It is executing a designed process with model calls in the middle.

That is not a failure. It is a workflow. And calling it an agent would be flattering the architecture beyond what it can bear.

I have watched this same pattern repeat in other builds. A system that looked impressively agentic in a controlled run would collapse the moment the environment got slightly dirty. It would pursue the wrong subgoal for too long. It would “remember” the wrong thing and build on the error like a bureaucrat defending a typo from 1997. It would use the right tools in the wrong order. It would recover cosmetically rather than structurally. In short, it could perform competence long before it could sustain it.

That gap is where most of the current agent hype lives.

Narration Is Not Agency

A lot of what is being marketed as agency is really orchestration with better dialogue. There is nothing dishonorable about orchestration. Most useful software is orchestration. The dishonesty begins when we pretend that chaining model calls together with a few conditional branches has produced a new species of autonomous actor.

It has not. Not by default.

A customer support pipeline that classifies tickets, searches a knowledge base, drafts a reply, and escalates edge cases may be excellent software. But unless it can retain meaningful context over time, adapt under new conditions, manage its own failures intelligently, and operate under consequences that affect future action, it is still better described as a workflow than an agent.

I built a small corporate text adventure called D.O.R.K. that makes this distinction uncomfortably visible. It runs in two modes: a classic parser-driven game with fixed rooms, puzzles, inventory, a suspicion meter, and multiple endings, and an optional AI narrator mode that wraps the same underlying world in fluid, conversational language. The experience feels markedly different between the two. The narrator version feels more alive, more responsive, more like engaging with something that understands you. But the game mechanics underneath are identical. The narrator changed the surface, not the structure. That gap between how a system feels and what a system actually does is where most of the current agent confusion lives. I will have more to say about this in a later essay.

The same observation applies to a large share of the so-called agent ecosystem right now. Much of it is useful infrastructure. Some of it is promising. But a distressing amount of it is still a sequence engine in a blazer, speaking confidently enough that people stop asking what, exactly, is doing the deciding.

The Agency Problem

That last question matters. Once a system is granted the aura of agency, people begin trusting it differently. They delegate more freely. They excuse errors as “just a glitch” rather than evidence of a structural limitation. They build institutions around the assumption of capability that the underlying code cannot consistently deliver.

The problem is not that the work being done across this industry is trivial. It is not. Serious engineers and researchers are building genuinely useful systems, and the progress in tool orchestration, state management, and planning over the past two years has been substantial. The problem is that the framing has outgrown the foundations. These observations reflect what is commonly deployed in production as of early 2026, not what any given framework promises on its roadmap. When every software wrapper with a loop, a prompt, and access to a weather API is marketed as an autonomous agent, the term stops functioning as a description and starts functioning as aspiration dressed up in the present tense.

If we keep calling workflows agents, we risk two futures worth avoiding. One where builders stop pushing on the hard parts, consequence-aware design, robust planning, real error recovery, because the demos already “feel” agentic enough to ship. And another where users and regulators treat these systems as autonomous actors, assigning blame or credit that the underlying code cannot bear.

Neither future is honest. And honesty about what we are building is not a concession to timidity. It is an engineering discipline. If you have ever worked inside a Lean Six Sigma framework, you know the principle: you cannot improve what you cannot accurately measure, and you cannot measure what you have not honestly named. The same applies here. Calling a workflow an agent does not upgrade the architecture. It degrades the vocabulary.

What Comes Next

The rest of this series will unpack what it actually takes to cross from workflow to something worthy of the label. We will look at real architecture: memory, tools, planning, and what happens when those components interact under pressure. We will examine why consequence is the ingredient most agent demos quietly omit, and why that omission matters more than any missing feature. We will ask what happens when multiple so-called agents are put in a room together, and why the result looks less like collaboration and more like the organizational pathologies we already know from human institutions. And we will end with a personal accounting: what I mean, and what I refuse to mean, when I say I am building an agent.

For now, the provocation stands.

Look at the AI agent system you are using, building, or investing in today. Run it against the criteria above. Does it retain memory across sessions? Does it use tools reliably in context? Does it plan and revise under changing conditions? Do its actions carry consequences that shape future behavior?

If the answer is yes to most of those, you may have something worth the name.

If not, you have a workflow. Perhaps a very good one. Perhaps a profitable one. But a workflow nonetheless.

And a workflow in a trench coat is still just a workflow.

∗  ∗  ∗

Next in The Agency Problem: “The Architecture of Actually Doing Something”

∗  ∗  ∗

Further Reading

Hannah Arendt, The Human Condition (1958). Arendt’s tripartite distinction between labor, work, and action remains one of the sharpest frameworks for understanding what separates rote production from situated, consequential doing. Her concept of action as the capacity to begin something new under conditions of plurality maps provocatively onto the question of what AI systems can and cannot initiate.

Daniel Dennett, The Intentional Stance (1987). Dennett’s argument that we predict behavior by attributing beliefs and desires to complex systems explains why language models trigger such strong projections of agency. The intentional stance is a predictive strategy, not a metaphysical commitment, and that distinction is central to understanding why fluent narration is not evidence of autonomy.

Stuart Russell and Peter Norvig, Artificial Intelligence: A Modern Approach, 4th edition (2021). The standard AI textbook defines agents as systems that perceive, persist, adapt, and pursue goals. That definition, three decades old, remains more demanding than most of what the industry currently ships under the label.

Anthropic, “Building Effective Agents” (December 2024). A practical taxonomy of agentic patterns from the makers of Claude, distinguishing workflows from agents and mapping common architectural patterns. Useful as a technical complement to the philosophical framing above.