The workflow audit decides what gets built before the cost telemetry measures what's running.
The cost crisis conversation everyone is writing about focuses on what to do with the agents already running. Telemetry, cost-per-run, budget gates, model routing. All of that work matters. None of it answers the question that comes before any of it. Should this workflow be an agent at all?
Most production AI builds operate on workflows that are 70-80% rule-based at their core, with a 20-30% layer of genuine judgment at the edges. Treating the whole workflow as an agent means paying agent-level token cost for the encodable 80%. The architectural call comes before the telemetry call. The workflow audit is where the architectural call gets made.
This is the upstream cost discipline that pairs with the telemetry layer Magnetiz covered last week.
Here is the map.
What is the workflow audit?
The diagnostic that runs before any agent build.
The workflow audit is the pass that reads the existing workflow end-to-end, codes the steps in plain language, tags each step as rules-required or judgment-required, and clusters the result into two layers. The encodable layer that runs as automation. The judgment layer that runs as an agent. The split determines the architecture.
Rules-required steps have a deterministic answer. Given the input, the output is predictable. Pattern match on form fields. Schema validity check. Conditional routing rule. Field update on stage change. Lifecycle trigger.
Judgment-required steps require reading ambiguous context, weighing multiple signals, or producing output that varies meaningfully across similar inputs. Discovery insight extraction. Voice-matched personalization. Cross-source risk surfacing. Strategic recommendation.
The audit takes 1-3 days for most GTM workflows. The output is a decision document that names what gets built where.
Watch for teams that skip the audit because the workflow “feels like AI.” A lot of workflows feel more AI-shaped than they actually are. The intuition tends to be unreliable.
Why do most workflows split 70-80% rules and 20-30% judgment?
The decoration pattern.
Most GTM workflows are end-to-end processes with multiple steps. Roughly 70-80% of the steps in any given workflow are deterministic. Read the inbound, classify, route, update field. Pull from CRM, format, send to Slack. Match against ICP criteria, score, surface above threshold.
The remaining 20-30% is where genuine judgment lives. Reading whether a discovery call signaled real intent versus polite curiosity. Choosing between two equally-valid outreach angles based on subtle context cues. Weighing competing signals when they point in different directions.
The split holds because most workflows are systems-of-record work with judgment decorated at the edges. The agent layer earns its cost on the judgment edges. The rules layer absorbs everything else.
Watch for workflows that feel 100% judgment. They usually decompose into 70-80% rules once 50 historical examples get read carefully. The intuition that “this is all judgment” produces over-engineered agent builds.
How do you tell the encodable layer from the judgment layer?
Three tests. Apply each step against all three.
The determinism test. Given the same input, would two different domain experts produce the same output? If yes, the step is encodable. If no, the step might be judgment.
The variance test. Across 50 historical examples, does the output vary meaningfully based on context cues that aren't captured in structured fields? If yes, the step is judgment. If no, the step is encodable.
The reversibility test. If the output is wrong, what's the recovery cost? Cheap recovery means automation can fail forward. Expensive recovery means human-in-the-loop or agent-with-eval-gate.
Most steps pass the determinism and variance tests cleanly. The ambiguous steps fall in the residual 20-30%.
Watch for steps that pass determinism but fail variance. Those are usually places where the workflow has hidden rules that haven't been written down yet. Write the rules down. The step often moves from judgment to encodable.
What does a workflow audit look like in practice?
Inbound qualification as the worked example.
End-to-end workflow from form fill to qualified-lead-handoff.
Steps in order. Form submitted. Capture fields. Enrich with firmographic data. Classify intent based on form responses. Route based on segment fit. Score the lead. Flag for SDR review if score exceeds threshold. SDR makes the qualification call on borderline leads. Update CRM with disposition.
Rules-required steps. Capture, enrich, classify against pattern library, route by segment, score against formula, flag by threshold, update CRM. Seven of nine steps. All deterministic.
Judgment-required steps. SDR makes the qualification call on borderline cases. One to two of nine steps depending on how the call breaks down. The judgment layer is the SDR review on edge cases the score model couldn't resolve cleanly.
Architecture decision. Build the seven rules-required steps as automation. Build the agent only for the judgment step. Or keep human judgment on the residual and run an agent as a copilot to the human reviewer.
This is the inbound consolidation pattern Magnetiz shipped across the GTM motion. The 80% encodable layer runs as automation. The 20% judgment stays with one human plus an agent copilot. The cost shape of the whole workflow drops because the 80% runs at automation prices, not agent prices.
Watch for builds that bypass the audit and ship agents on the 80%. The cost compounds at scale. The team loses trust in the agent because it's making decisions a human would make the same way every time. Predictable work shouldn't run on non-deterministic infrastructure.
Why do agent-on-everything builds blow the cost budget?
The compounding math.
Agents are non-deterministic infrastructure. Each run carries token cost, latency, and failure modes that don't exist in rules-based code. When an agent gets pointed at a deterministic problem, the agent works. The LLM is smart enough to handle the encodable layer. Every run costs orders of magnitude more than the equivalent rule.
Concrete shape. A rules-based lead-scoring step runs in microseconds at near-zero cost per evaluation. The same step routed through an agent costs 500-2000 input tokens, 100-500 output tokens, and runs in seconds. At 10,000 leads per month, the rules path costs essentially nothing. The agent path runs $200-800 per month for the same outcome.
Multiply across every rules-required step in the workflow. Seven rules-required steps × $200-800 each × 10,000 leads per month equals $14K-56K monthly cost spread across a workflow that should have cost a couple hundred dollars in automation infrastructure.
The cost compounding is predictable. The workflow audit catches it before the build ships.
Watch for cost-per-business-outcome numbers that don't make sense. They are usually the symptom of an agent doing rules-layer work in production.
How does the workflow audit pair with cost telemetry?
Two layers of cost discipline.
Last week's Magnetiz newsletter covered cost telemetry. Per-run logging, category breakdown, budget gates. That work measures what's running.
The workflow audit decides what runs in the first place. Same architecture, two layers of cost work.
Together they form a complete economic contract. Audit before the build for the architectural cost decision. Telemetry after the build for the runtime cost decision. Skip either layer and the cost economics break.
Cost telemetry tends to surface first because the bill is already arriving. The audit goes upstream of that. Run the audit on new builds before the bill exists. Run the audit on existing builds to identify where current agents should have been automations. Migrate the encodable layer down to automation. Reserve the agent budget for the actual judgment layer.
Teams that ship this discipline run agent budgets that scale linearly with judgment work, not with workflow volume.
Watch for ballooning agent costs that track workflow volume rather than judgment volume. That's the audit signal screaming.
What's the architectural contract every production AI build earns?
Three contracts. The architecture, the quality, and the economics.
Production AI agents earn autonomy by passing three contracts now.
The quality contract. Eval framework with binary scoring per axis. 5+ consecutive passing runs before autonomous deployment. Telemetry catches quality drift.
The economic contract. Cost-per-run logging. Budget gates per agent. Telemetry catches economic drift before it lands on the invoice.
The architectural contract. Workflow audit before the build. Rules for the encodable layer. Agents for the judgment residual. Telemetry catches misalignment between the audit and the actual usage pattern.
Three contracts. Three layers of discipline. The bias on every new build is toward agent-on-everything because the AI tools make it easy. The discipline is restraint at the architectural layer, instrumentation at the runtime layer, and gating at the autonomy layer.
The pattern across all three contracts
The cost crisis is a telemetry crisis. The cost crisis is also an architectural crisis. Teams pulling back on AI are pulling back from builds that didn't pass either contract. The fix is upstream of both.
Audit the workflow. Build rules for the encodable layer. Reserve agents for the judgment residual. Measure everything that runs.
Rules first. Agents for the residual.
FAQ
What is the AI workflow audit?
The AI workflow audit is a diagnostic pass that runs before any agent gets built. It reads the existing workflow end-to-end, tags each step as rules-required or judgment-required, and clusters the result into the encodable layer (automation) and the judgment layer (agent). The audit determines what gets built where before any code ships. Most GTM workflows split roughly 70-80% rules and 20-30% judgment.
Why don't most GTM workflows need AI agents end-to-end?
Most GTM workflows are systems-of-record processes with judgment decorated at the edges. The rules layer absorbs everything that's deterministic. The agent layer earns its cost on the judgment edges. Treating the whole workflow as an agent pays agent-level token cost for the deterministic 70-80% that could have run on rules at near-zero cost. The economics compound across every rules-required step.
How do you separate the rules layer from the agent layer?
Three tests. The determinism test asks whether two domain experts would produce the same output on the same input. The variance test asks whether output varies meaningfully across 50 historical examples. The reversibility test asks what the recovery cost is if the output is wrong. Steps that pass determinism and variance cleanly are encodable as rules. Steps that fail those tests are agent layer.
What does an agent-on-everything build cost compared to a rules-plus-agent build?
An agent run carries token cost proportional to input context, output length, and any tool calls or sub-agent invocations. A rules-based step on the same workflow runs in microseconds at near-zero cost. At 10,000 records per month across 7 rules-required steps, the agent path costs $14K-56K monthly for an outcome that should have cost a couple hundred dollars in automation infrastructure. The compounding math is predictable.
How does the workflow audit pair with cost telemetry?
The workflow audit decides what gets built (architectural cost decision). Cost telemetry measures what's running (runtime cost decision). Together they form a complete economic contract for production AI. Audit upstream of the build. Telemetry downstream of the build. Skip either layer and the cost economics break. Teams that ship both run agent budgets that scale linearly with judgment work rather than workflow volume.
What's the architectural contract for production AI builds?
The architectural contract states that workflows get decomposed by the audit before any code ships. Rules-required steps run as automation. Judgment-required steps run as agents. The contract sits alongside the quality contract (eval framework with binary scoring) and the economic contract (cost telemetry with budget gates). Three contracts together gate every production AI build before it earns autonomous status.
Why does the intuition that “this is an AI workflow” tend to be unreliable?
The intuition pattern-matches on the presence of judgment-required steps somewhere in the workflow. The intuition treats the whole workflow as judgment-required because some of it is. Reading 50 historical examples usually shows that the same workflow is 70-80% deterministic. The intuition over-counts judgment because workflow design discussions surface the hard parts most, while the easy parts feel invisible. The audit corrects the bias by forcing every step to pass the three tests explicitly.