Deterministic chaining: when you don't need the LLM to decide

Not every pipeline step is a decision. Tag the computable ones and the kernel runs them itself — the model only wakes for the choices that matter.

Your deploy pipeline is four steps: lint, test, build, deploy. The first three either pass or they don’t — there’s no judgment in them. But your agent treats all four the same way. It stops and thinks before every one, including the three that were never decisions.

That’s wasted work, and it’s the most wasteful kind: the model spending its expensive attention on steps that have a known, computable outcome.

The round-trip problem

Walk through what happens without chaining. The model starts the workflow, gets the lint step, reads the response, reasons about it, picks the transition, submits, waits for lint, gets the result, reasons again, picks the next transition, and on. Every one of those is a full model round trip, and each costs you four things:

input tokens to re-read the workflow state
output tokens to “reason” about a choice that isn’t one
network latency, end to end
API cost that scales with how long the conversation has grown

Put rough numbers on it. A 10-step pipeline where 8 steps are computable means 8 round trips that exist only to produce “yes, proceed.” Each re-sends the workflow state and spends output tokens — the expensive kind — reasoning about a step with one possible outcome. Eight times, per run, every run. The pipeline that should cost one model interaction costs nine.

Tag it and forget it

The fix is one field on a transition: actor: deterministic.

states:
  lint:
    transitions:
      run_lint:  { target: test,  actor: deterministic }
  test:
    transitions:
      run_tests: { target: build, actor: deterministic }
  build:
    transitions:
      package:   { target: ready, actor: deterministic }
  ready:
    transitions:
      deploy:    { target: live,  actor: agent }   # the chain stops here

When a state’s next move is deterministic, the kernel chains through on its own, threading each result into the next. The model calls praxec.command once with the workflow’s definitionId; the kernel runs lint, test, and build back-to-back and the response arrives at ready — three real commands run, zero LLM round trips, with a chain trace attached. The model is consulted exactly once, at the one step that’s a real decision: whether to deploy.

You’re not removing the model. You’re refusing to pay it to rubber-stamp outcomes that were never in question.

Written by Matt C