You cannot optimise what you have not defined.

The same request takes a different path every time.

Prompts live in code. Nothing formal governs what happens next, so the route changes run to run and drift is the steady state rather than an incident. It stops partway and leaves you holding half an artifact. You sit and watch it work, because unattended is a risk with no bound on it.

The model is not the problem. The absence of a definition is.

“Good” exists inside the model and inside your head, and nowhere else — so there is nothing to check an output against, nothing to notice drift from, and no way to answer whether the cheaper model would have done just as well. The same model, handed a contract, produces something checkable instead. Structure is not the luxury tier here; it is the floor for getting anything dependable out of a model at all.

So write it down, outside the model. Four kinds of file.

Types

The data shapes. Everything else binds to these, so they come first.

Agents

Producers. Each declares its input types, its output types, its tool grant and its model tier.

Skills

Reusable capability, including executable code — which has to pass its own fixtures before it can be promoted.

Standards

A graph of phases. Each phase seats chairs, and a chair binds a producer to an input contract and an output contract, written in type slugs.

Between them, those four files are the definition of a good job: the shapes the work has to produce, the evidence each one has to carry, the criteria a judgment is made against, and the fixtures a skill still has to pass.

{
  "phase": "assess",
  "chairs": [
    {
      "role": "analyst",
      "agent_slug": "impact-analyst",
      "input_contract":  ["incident-report"],
      "output_contract": ["impact-assessment"]
    }
  ]
}

Phases connect by type. Not by name.

An edge exists exactly where an upstream output contract satisfies a downstream input contract. Which means compose time can tell you that a phase is asking for a shape nothing upstream produces — before you spend a run finding out at minute nine.

The floor holds no matter which model produced the output.

Six primitives, six core types, and each core type carries one substance field that has to be present when the output is sealed. Not a warning, not a lint, not a score you can override. The write is refused and the run stops.

{
  "type": "impact-assessment",
  "primitive": "INTERPRET",
  "claims": [
    "checkout latency exceeded 2s for 41 minutes",
    "the retry loop in the payments client amplified load"
  ],
  "confidence": 0.82
}

Evidence and output are the same object, so there is no version of the artifact that exists without it. And because the floor sits outside the model, swapping the model out cannot quietly lower it — which is what makes a change safe to make.

When it stops, that is a position — not a mess.

Work is a graph of discrete phases, and every completed phase seals a durable output. A run that halts partway leaves finished, content-addressed steps on disk rather than half an artifact and a guess about what got done. You resume from the last sealed phase and pay only for what has not run.

coltrane dispatch <standard> --resume <gig-id>

The part that matters is the refusal. If the definitions, the producers, the payload, the model or a consumed type changed while the run was stopped, the resume is refused and told you exactly what drifted — rather than splicing two different versions of the work together under one identity. You either resume the run you started, or you are told why you cannot.

Same idea one level down: a step that did not produce what its contract promised is reported, not waved through as complete. And when you set a per-run ceiling in dollars, the run stops rather than starting the step that would spend past it, so unattended does not mean unbounded.

Which is the point. The reason anyone sits and watches these runs is that an unattended stop costs them the whole thing. Durable phases and a resume that refuses are what make it safe to walk away.

You are not buying tokens. You are buying output you would sign.

The bill counts every attempt. The value counts only the ones that held up, and the gap between those two numbers is where most of an inference budget goes — re-run, re-prompt, discard, fix by hand. Coltrane does not make inference cheaper. It stops you buying the same thing twice, and stops you paying for output you were going to throw away.

And once you can see the conversion, you can change what produces it.

Cost and quality are recorded against the same unit of work, so a producer can be compared against the version it replaced, and a step can be moved onto a cheaper model and measured rather than argued about.

Eight times cheaper for four tenths of a rubric point is a decision somebody can actually make. Spend expensive tokens once to find out where the cheap ones hold, then run cheap — and let the floors and the fixtures, not your nerve, be the thing holding the line.

What running it actually involves.

Including the awkward parts, which are the ones worth knowing before you start rather than after.

The definition is the asset. The model is an input you swap.

A model handed a contract — the shape it must produce, the evidence that shape has to carry, the criteria it will be judged against — does better work than the same model handed a paragraph of hopeful prose. Not a different model. The same one, improved, because it was finally told what the job is.

Which makes the definition an upgrade applied to every model that touches the work: the one you run now, the cheap one you are considering, and the one that ships next quarter that nobody has heard of yet. Improve the definition once and everything downstream of it improves with it. Prompt-tuning accrues to one model and evaporates the day you change it.

The model is rented. The definition is owned.

So adopting a cheaper or more specialised model stops being a re-tuning project you keep postponing. Point a step at it, look at whether it still clears the bar, keep it or don’t.