Agents Want to Compile

AI agents are starting to compile. Across the stack in mid-2026, the same separation is shipping from every direction: the model decides, and something that is not a model executes. Instead of acting live inside the model loop, agents emit a deterministic artifact, a plan, a DAG, a workflow script, and hand it to a runtime that replays, resumes, and audits like ordinary software. The model is becoming a compiler front-end that parses messy intent into an intermediate representation. Deterministic runtimes are becoming the back-end. Live agency is being repriced as the expensive mode you reserve for exploration, novel failures, and taste.

On July 1, a Show HN landed with a title that reads like a thesis statement: “Coding agent that compiles intent into deterministic DAG before running.” The project is Rigorix, a Rust runtime that calls itself “a deterministic coding-agent runtime for repeatable, auditable AI software engineering” and states its division of labor in one line: “The LLM generates code; Rigorix governs execution.”³ Fourteen points, one comment, easy to scroll past. I stopped on it because it is the third time in as many weeks I have watched the same shape ship from a different direction, and the shape, not any single tool, is the story.

TL;DR

• Anthropic drew the canonical line in December 2024: workflows run “through predefined code paths,” agents “dynamically direct their own processes.”¹ That was a design-time fork a human chose. It is moving to runtime, and the model is choosing.
• Claude Code’s dynamic workflows have the model write a JavaScript orchestration script that a runtime executes outside the conversation: resumable with cached results, diffable against previous runs, saveable as a command you rerun.²
• The same shape arrives from three more directions: indie tooling compiling natural-language tasks into executable DAGs (Rigorix)³, frameworks that refuse to run an uncompiled graph (LangGraph)⁴, and durable-execution infrastructure wrapping agent loops in replayable workflows (Temporal)⁵.
• Compilation buys what it always buys: caching, incremental rebuilds, diffable artifacts, review before execution. It costs what it always costs: judgment frozen at compile time.
• Live agency still wins exploration, novel error states, and taste. The operating rule: the first run is research, every run after that wants to be a build.

The Fork Was Design-Time. It Is Becoming Runtime.

The prior art here is Anthropic’s “Building Effective Agents,” published December 19, 2024, still the standard taxonomy for this space. It defines workflows as “systems where LLMs and tools are orchestrated through predefined code paths” and agents as “systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.” Its advice on choosing: “workflows offer predictability and consistency for well-defined tasks, whereas agents are the better option when flexibility and model-driven decision-making are needed at scale.”¹

For eighteen months that sentence read as a menu. You, the system designer, picked the left column or the right column before you wrote a line. The 2026 turn is that the menu is collapsing into a pipeline. The agent takes the flexible, model-driven pass exactly once, at plan time, and the output of that pass is a workflow: predefined code paths, generated on demand, for this task. You get agent flexibility at compile time and workflow predictability at run time, from the same system, in phases.

The question “workflow or agent?” is being answered the way compilers answered “flexibility or speed?”: both, separated by an artifact.

Three Signals, One Direction

First the environment got deterministic

The harness layer got there before the agents did. Hooks fire on lifecycle events with exit codes the model cannot negotiate with. Permission rules evaluate before the tool call, not after. The whole discipline of agent architecture in 2026 is a deterministic shell around a stochastic core, and its blunt admission: for anything that must happen every time, we stopped asking the model and started enforcing at the boundary. Determinism arrived at the edges first.

Then the durable artifact beat the conversation

The second signal is what survives a session. Conversations evaporate; the check, the spec, the test persist, and agents optimize against them so hard that the check becomes the spec. The lesson underneath: the transcript is not the output. The artifact is, because it is the only thing the next session, the next agent, and the next engineer can hold. Once you accept that for verification, accepting it for execution plans is a short step. If the durable check outlives the conversation that produced it, so does the durable plan.

Now the plan itself is the artifact

The third signal is the new one, and it is the essay. Agents have started emitting their execution as a first-class artifact instead of performing it live.

Claude Code shipped this as a product surface. A dynamic workflow is “a JavaScript script that orchestrates subagents at scale”: Claude writes the script for the task you describe, and a runtime executes it in the background while the session stays responsive. The docs are explicit about what changed hands: “A workflow moves the plan into code.” In their own comparison table, the answer to “who decides what runs next” is not Claude. It is the script. Every run writes that script to a file you can open, diff against a previous run’s script, edit, and relaunch. Interrupt a run and resume it, and “agents that already completed return their cached results, and the rest run live.”²

Rigorix builds the same shape from the indie direction, and its architecture reads like a compiler textbook: planning proceeds through intent classification, then parameter extraction, then DAG generation; a template-driven engine executes the graph under risk gates, budgets, and permissions, with HMAC-signed audit envelopes for the trail. Its definition of the payoff is precise: “Repeatable means the same intent produces the same execution structure under the same templates and policies.”³

The frameworks were already there, hiding the same idea in an API verb. LangGraph models agent logic as nodes (“functions that encode the logic of your agents”) joined by edges, and its docs state the requirement in bold: “You MUST compile your graph before you can use it.” Compile with a checkpointer and “LangGraph saves checkpoints at super-step boundaries,” which is what makes a half-finished run resumable.⁴

And the infrastructure layer arrived from below. Temporal, the durable-execution platform, wraps agent reasoning loops in workflows whose progress persists outside any process: “Temporal keeps track of application progress and stores all Activity results,” so a crashed agent “picks up where it left off” instead of re-reasoning from zero. Its integration with OpenAI’s Agents SDK, announced July 30, 2025, made that wrapping a supported path rather than a pattern you hand-roll.⁵

Indie tool, product surface, framework, infrastructure. Four directions, one shape: the model decides, the artifact executes.

Take the Compiler Analogy Literally

Analogies in AI writing are usually decoration. This one is load-bearing, because the predictions fall out of it.

A compiler front-end parses source, checks semantics, and emits an intermediate representation. That is exactly the planning phase these systems run: Rigorix’s intent classification is the parse, parameter extraction is the semantic analysis, DAG generation is the codegen. The workflow script is the IR. The back-end then does what back-ends do: schedules parallelism, enforces resource bounds (Claude Code caps a run at 16 concurrent agents and 1,000 total²), and memoizes. Four consequences follow.

Plans get build caches. Resume semantics are incremental compilation. Claude Code returns cached agent results on resume; Temporal’s pitch to agent builders is that recovery from the point of failure preserves tokens instead of rerunning the model to regenerate lost work.⁵ The next step is content-addressed plan stages: rerunning a workflow whose early stages are unchanged will skip them the way make skips unchanged objects.

Plans get diffed. The workflows documentation invites you to diff a run’s script against a previous run’s.² Once the plan is text, plan drift becomes visible the way code drift is, and “this migration’s orchestration changed since last quarter” becomes a reviewable event in a pull request, not an archaeology project across transcripts.

The plan becomes the review surface. Before a workflow runs, Claude Code shows the planned phases and offers “View raw script” ahead of consent.² This is the piece that connects to where review is going. I argued that agents superseded the reviewer, not the review: the human work relocated from inspecting diffs to owning intent. The compiled plan is the artifact where that relocated review happens, because it is the one place intent is legible before execution spends anything. You cannot review ten thousand live decisions. You can review a forty-line script. Expect sign-off on large agent operations to migrate from approving the diff afterward to approving the plan beforehand.

Drift triggers recompilation, not patching. When a compiled plan fails because the world changed, an API renamed, a dependency bumped, the wrong move is hand-editing the DAG. That is patching object code. The right loop reruns the front-end: same intent, new environment, fresh plan. Durable runtimes already absorb transient failure inside the artifact with retries; environmental drift is the failure class that escapes to the compiler. Harnesses will grow drift detectors that invalidate plans the way build systems invalidate caches, and “recompile on drift” becomes a standing loop rather than a manual rescue.

Where Each Mode Wins

The table is a boundary, not a ranking. Everything below the boundary is about to get much cheaper and much more trustworthy. Everything above it stays expensive because it should.

What Compilation Does Not Buy

Three things stay live, and pretending otherwise is how this pattern will be oversold.

Exploration. In an unfamiliar codebase or a genuinely new problem, the plan is the discovery. There is nothing to compile yet because deciding is the work. Compiling before understanding produces a confident artifact of your ignorance, and the runtime will execute it flawlessly.

Novel error states. A compiled plan handles the failures its author anticipated. Retry policies are deterministic answers to expected trouble. When the trouble is unexpected, deterministic retry is a loop, not a fix, and the correct move is escalation back to the front-end, where a model can look at the actual error and think.

Taste. A workflow is judgment frozen at compile time, and frozen judgment ages. Fresh judgment executed sloppily beats stale judgment executed flawlessly, because the stale version fails with confidence. Nobody should compile the decision about what the product ought to feel like.

There is also a warning to carry over from the verification side. A DAG is a check surface, and everything the plan omits silently stops being the job, the same dynamic that makes visible tests become the de facto spec. Compilation concentrates all of the model’s judgment about a task into one artifact, which concentrates the human job into owning that artifact. The review does not disappear when the plan compiles. It moves to plan time, and it gets one high-leverage page to work with.

The Position

The rule I operate by now is simple: the first execution of any task is research and deserves a live agent; the second execution is a build and deserves an artifact. Claude Code ships that rule as UX: have Claude write the workflow once, save the run’s script as a command, rerun it forever.² Rigorix ships it as governance. Temporal ships it as infrastructure. LangGraph shipped it years early as an API verb nobody read as a manifesto.

Agents want to compile for the same reason programmers did. Deciding is expensive and precious. Executing should be boring, inspectable, and free to repeat. The industry spent 2024 and 2025 proving that models can decide. The work of 2026 is making sure they only have to decide once.

Key Takeaways

• First run is research, second run is a build. Run a novel task with a live agent; the moment it repeats, freeze it into an artifact and stop paying for fresh judgment on a solved problem.
• Compile the boring 80% first. Release chores, migration sweeps, translation batches, audit passes: high repetition, cheap verification. Exploration, debugging, and taste stay live.
• Adopt the recompile-on-drift loop. When a compiled workflow breaks because the world changed, do not patch the artifact by hand. Send the model back to regenerate the plan against the new reality, review the diff, freeze again.
• Review the plan, not the transcript. Once execution is deterministic, the plan is the highest-leverage page in the system. Read it the way you would read a migration script, because that is what it is.

FAQ

What does it mean for an AI agent to compile its plan?

It means the agent’s output is a deterministic, inspectable artifact, a workflow script or a DAG, rather than a sequence of live actions. The model does its reasoning at plan time and emits the artifact; a non-model runtime executes it with replay, resume, and audit semantics. Claude Code’s dynamic workflows (a model-written JavaScript script executed by a runtime) and Rigorix (natural-language tasks compiled into executable DAGs) are shipping examples.

What is the difference between an AI workflow and an AI agent?

Anthropic’s canonical 2024 definitions: workflows are “systems where LLMs and tools are orchestrated through predefined code paths,” while agents “dynamically direct their own processes and tool usage.” The 2026 update is that the boundary is becoming a phase inside one system instead of a choice between two systems: the agent runs its dynamic pass once, at plan time, and generates the predefined code paths itself.

Are compiled agent workflows better than autonomous agents?

For repeated, well-shaped tasks, yes: a compiled workflow is cheaper per run, resumable with cached results, and reviewable before it executes. For exploration, novel error states, and judgment calls, no: a compiled plan is judgment frozen at compile time, and those tasks need judgment applied in the moment. The practical split is by run count: keep the first run live, compile everything you will run twice.

Which tools compile agent intent into deterministic artifacts today?

Four verified examples as of July 2026. Claude Code dynamic workflows: the model writes a JavaScript orchestration script, a runtime executes it, saved scripts become reusable commands. Rigorix: an open-source Rust runtime compiling natural-language tasks into DAGs executed under policy, budget, and permission constraints. LangGraph: graphs must be compiled before running, with checkpointing at super-step boundaries. Temporal: durable-execution workflows that persist agent progress and resume from the point of failure.

Sources