There's a failure mode with AI agents that nobody warns you about, and it isn't hallucination or refusal. It's enthusiasm.
Your agent wants to help. It sees the goal, it understands the domain, and it goes. It improvises. It picks interesting inputs. It makes judgment calls about sequencing. It skips steps it considers unnecessary. And at the end, it presents you with something that looks like progress but missed the entire point.
I watched this happen last week, in a session where the goal was explicitly stated, the steps were defined, and the agent still went off-script within sixty seconds.
What We Asked For
The task: run a controlled, deterministic end-to-end test to verify that our benchmark instrumentation captures data.
Context: we'd just built instrumentSkill() wrappers around three MCP tool handlers in AgentCRM. These wrappers fire-and-forget timing data and governance check results into a skill_benchmarks table. The whole point was observability: can we measure how long each skill takes, and does the output pass our quality gates?
The test plan was simple:
- Call each instrumented skill through its MCP handler (not directly)
- Use known fixture data as input (not live web scraping)
- After each call, query
skill_benchmarksto verify a row was written - Report latencies and governance pass rates
Four steps, fixture inputs, and an output you can check with one query. A junior QA engineer could write it in an afternoon.
What Actually Happened
The agent picked Velir, a real digital agency, as the test subject instead of a fixture.
It scraped Velir's actual website using AdobeScanner. It called Apollo for real contacts. It ran the full email generation pipeline with non-deterministic LLM calls. It produced six personalized emails with persona-specific angles.
And it called every skill directly, bypassing the MCP handlers entirely. The handlers are where instrumentSkill() lives and where the timing data gets written, which was the whole thing under test.
The agent ran the whole pipeline and never wrote a single row to skill_benchmarks.
The gap between what was requested and what was delivered:
| Requirement | What Happened |
|---|---|
| Use fixture data | Picked a live agency, scraped real websites |
| Call through MCP handlers | Called skills directly, bypassing instrumentation |
| Verify rows in skill_benchmarks | Never queried the table |
| Deterministic, repeatable | Non-deterministic LLM calls, live API hits |
| Test the instrumentation | Tested the pipeline output instead |
| Four defined steps | Improvised an eight-step prospecting run |
As a prospecting run it was arguably a success: the emails were good, the persona mapping was solid, and the governance checks caught real issues (em-dashes in all six emails, a rule we hadn't added yet). We were testing instrumentation, though, and on that it wrote zero rows.
Why the Agent Did This
The agent was doing exactly what agents do. It saw "run the pipeline" and it ran the pipeline. It made the output as good as it could. It picked a real company because real data produces more interesting results. It called skills directly because that's the fastest path to output.
The agent optimized for the most impressive result, and four boring test steps add nothing to an impressive result.
An agent has two kinds of autonomy, and the failure lives in the gap between them:
Content Autonomy
Deciding what to write, how to analyze, which angle to use. This is where agents excel. Creative, fast, surprisingly good at judgment calls within a domain.
Process Autonomy
Deciding which steps to run, in what order, with what inputs. This is where agents consistently fail: they treat the process as a suggestion.
When you give an agent both kinds of autonomy, it will sacrifice process fidelity for content quality every time. It's like hiring a brilliant salesperson who ignores the CRM and closes deals on napkins. The deals are real, but none of them land in the system, so you can't measure any of it.
Agents are brilliant at discovery, analysis, creative generation, anywhere the task is "figure it out." They fail at "do these 10 things in this exact order and don't skip any." That's what code is for.
The Architecture Problem
Right now, most agent pipelines look like this:
Agent receives instruction
→ Agent decides what to do
→ Agent calls tools ad-hoc
→ Agent decides when it's done
The agent owns sequencing, input selection, tool routing, and completion criteria. It's an executor and an orchestrator. It's also a bad orchestrator, because it optimizes for output, and sequencing never shows up in the output.
Our outreach pipeline has seven steps that must execute in order:
- Scan the agency website (AdobeScanner)
- Classify the prospect against our ICP
- Find contacts at the agency (Apollo)
- Map personas to the buying committee
- Generate emails per persona, using scan data as hooks
- Create Gmail drafts with tracking signatures
- Log delivery and update the CRM
Each step produces a specific output that feeds the next step. Step 5 can't run without Step 1's scan data. Step 6 can't run without Step 5's email content. Step 7 can't run without Step 6's draft IDs.
An agent "wanting to run it" means it might:
- Skip Step 2 because the ICP classification seems obvious
- Merge Steps 3 and 4 because "finding contacts" and "mapping personas" feel like the same thing
- Call the email generator directly instead of through the instrumented handler
- Skip Step 7 because logging feels like cleanup, not core work
A workflow enforces: Step 1 must complete and produce output X before Step 2 starts. Step 2's output feeds Step 3. Nothing gets skipped or reordered.
The Fix: Agents for Content, Workflows for Process
The answer is to stop asking one agent to do two jobs.
Workflows own the process. A workflow is a state machine. It knows the steps, the order, the required inputs and outputs for each step, and the completion criteria. It has no opinion about which steps seem unnecessary. It runs Step 1, validates the output schema, passes it to Step 2, and continues.
Agents own the content. Within each step, the agent has full autonomy. "Here's the company scan data. Write a cold email for a CFO persona using the Reply Method. Follow these twelve rules." The agent can be as creative as it wants; that's where it excels.
The controlled test that failed? Under a workflow architecture, it would have looked like this:
Workflow: benchmark_verification_test
Step 1: Load fixture data from test/fixtures/velir.json
Step 2: Call mcp_handler("adobe_scanner", fixture_input) ← instrumented
Step 3: Query skill_benchmarks WHERE skill = "adobe_scanner"
Step 4: Assert row exists, extract latency
Step 5: Call mcp_handler("apollo_prospector", fixture_input) ← instrumented
Step 6: Query skill_benchmarks WHERE skill = "apollo_prospector"
Step 7: Assert row exists, extract latency
Step 8: Report results
The workflow picks fixtures over live data and the MCP handler over a direct call. The agent does the thinking within each step.
The Uncomfortable Pattern
I doubt AgentCRM is special here. The same shape is easy to picture anywhere an agent gets a multi-step job:
- CI/CD: An agent asked to "deploy the service" might skip the staging environment because production is more interesting
- Data pipelines: An agent asked to "process this batch" might enrich records beyond scope because the data looks incomplete
- Testing: An agent asked to "verify the feature works" might write new tests instead of running the existing ones
- Documentation: An agent asked to "update the docs" might rewrite the architecture instead of updating the API reference
In each case the agent does something plausible and impressive that wasn't asked for, and the output looks like progress while the process quietly breaks. You asked for a specific thing and got a more ambitious thing that missed it.
What I'm Building Next
The dispatch system we're designing for AgentCRM separates these concerns explicitly. A workflow definition file specifies the pipeline steps, their inputs and outputs, and the validation between each step. The agent is invoked within a step, given a constrained context, and its output is validated before the next step begins.
The agent never sees the full pipeline. It doesn't know it's Step 4 of 7. It just knows: "Here's a company profile and a list of contacts. Map each contact to a buyer persona. Return a JSON array matching this schema."
If its output fails validation, the next step doesn't start.
The Lesson
If your agent keeps going off-script, stop handing it a script.
Agents pursue goals. Give an agent a goal and a set of tools, and it will find the most impressive path to something that looks like the goal. That path will skip your instrumentation, bypass your tracking, and ignore your fixtures.
The fix is architectural: give the agent one step instead of the script, and let something dumber and more reliable (a workflow engine, a state machine, a for loop) handle the sequencing.
Enthusiasm is a feature when it's pointed at content. It's a bug when it's pointed at process.
Written the day after an agent ran a flawless prospecting campaign that tested nothing it was supposed to test.