Scrolling this morning's arxiv drop, most of what I saw was the usual rotation: another benchmark, another harness comparison, another "we ran N frontier models on SWE-bench Verified." Then I hit a single-author paper out of a production AIOps team that wasn't trying to make agents smarter at all — it was trying to make them disappear. The claim underneath it is that a good agent run isn't something you want to repeat; it's something you want to graduate into cheaper, dumber, deterministic code. That reframing is the most useful thing I've read this week, and it barely says the word "coding." My thesis: if you're building agentic coding pipelines, the highest-leverage move isn't a better model — it's a lifecycle that turns your agent's proven paths into workflows that never call the model again.
What it does#
Progressive Crystallization treats every automated behavior as living somewhere on a spectrum from fully stochastic to fully deterministic, and defines three execution types that are explicitly "not separate systems; they are lifecycle stages of the same discovered behavior." Type 3 is agent-orchestrated: sub-agents reason within bounded scope, humans gate the writes, roughly half the run is deterministic, and each pass burns 10k–50k tokens. Type 2 is hybrid: a fixed step structure where the LLM is only allowed to interpret or classify, every action is schema-validated, and cost drops to 1k–5k tokens. Type 1 is fully deterministic: pre-coded logic and typed API calls, no model at runtime, zero tokens, milliseconds.
The interesting part is the machinery that moves a behavior down the ladder. When an agent succeeds, the trace is parsed into an ordered list of tool calls, branch conditions are detected, per-step input/output schemas are inferred, a DAG of tool dependencies is built, instance-specific values (device IDs, timestamps) are parameterized, and human-approval points are marked as explicit gates — a reusable template, essentially recovered by process mining over agent logs. Promotion is evidence-gated: Type 3→2 needs ≥10 successful runs, zero safety violations, ≥90% identical action sequences, and passing auto-generated acceptance tests; Type 2→1 needs ≥50 hybrid runs, ≥99% classification consistency, a deterministic rule covering all observed input variation, and human review of the final logic. And crucially it runs in reverse: a circuit breaker demotes any playbook that hits an execution failure, safety violation, or acceptance-test regression. Their example is honest — a deterministic parser broke after a firmware update changed a command's output format, and the system automatically kicked that playbook back up to hybrid.
The key result#
On a production cloud-networking platform processing tens of thousands of incidents a month, the share of fully deterministic executions rose from zero to about 45 percent over eight months, and per-incident agent cost fell by more than 70 percent — while incident volume roughly doubled. That last clause is the whole argument. Costs didn't fall because traffic dropped or because they swapped in a cheaper model; they fell because the agent layer stopped being a per-occurrence expense and became a discovery mechanism whose cost is amortized across every future deterministic run of what it found. Alongside that, the platform resolved over 90 percent of common incident categories autonomously, mean time to resolution went from hours to minutes, and the false-positive remediation rate stayed under 5 percent.
Why it matters#
Most of the cost-reduction work I read tries to make each inference cheaper — cascades, routing, compaction, cheaper tiers. This paper makes a different and, to me, more durable point: for any task you've already solved a hundred times, the correct number of inferences is zero. The author frames it as orthogonal to FrugalGPT-style routing, and he's right. Model cascades keep the system probabilistic forever; crystallization removes the model from the hot path entirely once a behavior is proven. If you're running Claude Code sub-agents or a spec-driven pipeline in anything resembling a loop — CI triage, dependency bumps, migration codemods, release checklists, flaky-test quarantine — you are almost certainly paying full agent price on the tenth identical run that you paid on the first. The lesson is to instrument for repetition and build a promotion path, not just a prompt.
What makes this more than a cost story is that determinism buys you the two things production agent systems are worst at: reproducibility and auditability. The three types aren't just cheaper going down the ladder, they're safer — Type 3 leans on human-in-the-loop gates, Type 2 on schema validation, Type 1 on plain deterministic logic. That maps cleanly onto how I'd want a coding-agent fleet to behave: let the agent explore freely and gate its writes the first few times, watch whether it converges on the same action sequence, and once it does, freeze the discovered path into a checked-in workflow with acceptance tests. The demotion circuit breaker is the piece I'd steal first — it's the honest admission that a crystallized workflow is only valid until the environment shifts under it, and it turns "the automation silently broke" into "the automation noticed it broke and fell back to the agent." That's a much better failure mode than either a brittle RPA macro or an agent that cheerfully re-derives the same solution forever.
The caveats#
It's AIOps, not code authoring. The agents here remediate incidents, not write features. The crystallization lifecycle is domain-agnostic, but nobody has shown it works on the messier, more open-ended surface of writing and reviewing code.
It only pays off on recurring patterns. The author says so plainly: environments dominated by genuinely novel, one-off incidents stay stuck at Type 3, and crystallization buys you nothing. A lot of real coding work is exactly that kind of novelty.
The numbers are observational, not a controlled comparison. One organization, one operational domain, one eight-month maturity trajectory. The specific thresholds (≥10 runs, ≥99% consistency) should be re-derived, not copied.
Premature promotion is a real risk. Auto-promotion is only as good as the acceptance tests generated from traces, and an under-observed pattern can graduate too early — which is exactly why human review and demotion are load-bearing, not optional.
The takeaway#
What I'm filing away is a shift in how I think about the cost of an agent run. I've been treating a good trajectory as an output; this paper treats it as an asset with a depreciation schedule. The reframe I'm taking into my own pipelines: after a coding agent solves the same class of task enough times with a stable action sequence, that's not a success to celebrate and forget — it's a signal to extract the path, write acceptance tests around it, and demote the model out of the loop until something breaks. The agent's job, done well, is to make more of itself unnecessary.