In late 2023 I watched the OpenAI DevDay keynote and did what a lot of engineers did: I cleared my calendar. Assistants that would plan, act, and finish real work — the demos were right there. I took the agent courses. I built the orchestrations. When the Model Context Protocol arrived, I wired tools to models with real enthusiasm, because standardized tool access looked like the missing piece.
Then I did what the demos never do: I ran these systems against real enterprise work, for months, and watched where they went.
Two failure patterns kept repeating. The first was conversational drift — an agent that starts strong on a multi-step task and, fifteen steps in, is confidently solving a slightly different problem than the one it was given, because every step's small deviation compounds and nothing pulls it back. The second was orchestration failure — multi-agent designs where the choreography looked splendid on the whiteboard and dissolved in production, one agent's ambiguous output becoming the next agent's confident input, errors laundering themselves into results.
Meanwhile the market kept shipping things labeled "agentic." Look inside most of them and you find something more modest and more honest than the label: a deterministic workflow — a flowchart, drawn in advance — with an LLM at one or two nodes doing search, classification, or extraction. I once went through the published agent-ROI case studies I could find, looking for the loop. Case after case turned out to be a workflow with a language-model node in it. Useful? Often. Agents? No.
The definition I hold on to is close to Anthropic's, and it draws a sharp line: an agent is a system that dynamically directs its own process — a loop in which, each time new information arrives, the model decides the next step. If you can draw the control flow in advance, you have a workflow. Nothing wrong with a workflow. But the gap between what the word promises and what the box contains is the dissonance this piece is named for.
(You may have seen a widely shared statistic claiming ninety-five percent of enterprise AI pilots fail. I won't use it; I've never found support for it that survives a second look. The dissonance is real, but it doesn't need inflated numbers — the honest evidence is enough.)
Where the loop actually works
Here's what makes this a useful story rather than a cynical one. In those same three years, one domain quietly kept delivering, at increasing scale, with the loop genuinely running free: code generation.
It's worth being precise about why, because the reason is structural, not accidental. The agent loop fails where output is expensive to verify — drift and orchestration errors go unnoticed precisely because no cheap check catches them. Code is the one enterprise artifact where verification is nearly free: it compiles or it doesn't, tests pass or they don't, a type checker and a linter and an eval suite grade every iteration in seconds. The loop that drifts in a business process self-corrects in a codebase, because every pass through the loop hits a wall of cheap, deterministic feedback. Coding agents don't work because models are better at code than at insurance claims. They work because code answers back.
What I build now
That inversion reorganized my whole practice. The question stopped being "how do I make an agent reliable enough to run my process?" and became "how do I use the one reliable agent loop — the coding loop — to build the deterministic system my process actually needs?"
Agents building the workflows, rather than being them. The claims-intake pipeline, the reconciliation job, the reporting flow — these want to be boring, auditable, deterministic systems. What's new is that a coding agent can now build and maintain those systems at a speed and cost that changes what's feasible, provided you feed it the two things the demos never mention: substrate — your business captured as context the agent can use, documents indexed, entities and relationships made explicit, ways-of-working written down as skills — and verification machinery — gold sets and evals that turn "done" from an opinion into a measurement.
That's the unglamorous resolution of the dissonance. The revolution didn't arrive where the keynotes pointed. It arrived one layer down, in the tooling — and it rewards the organizations doing patient work on context and verification while everyone else re-labels their flowcharts.
The names and dates in the opening are my own history; the pattern, I suspect, is yours too.