The Function Framework

How an agent decides, and where determinism actually comes from.

Agent behavior is a pure function of three inputs, evaluated inside the turn:

behavior = f(context ⊕ prompt ⊕ weights)

There is no procedural memory between turns except what gets re-read into context. A turn is: read context, run the function, emit actions. Nothing else persists.

What determinism actually is

Determinism is not a property of the model. It is a property of how sharply the prompt and the tool surface constrain which output the function produces, across every plausible context the model might be holding.

You buy determinism three ways, all information-theoretic:

1. Shrink the interpretation space. Strict schemas, enums, canonical keys — not free text. Every place the model has to infer the canonical form of a thing is a place it can infer wrong.
2. Make failure loud. Never let a tool return a string that means two different things. Silent ambiguity is non-determinism wearing a costume.
3. Move invariants out of the model's head and into the tool. The model shouldn't have to remember the layout; the tool should canonicalize it — and report what it did.

The layers

The same three levers apply at every layer, and a bounded-context function resolves ambiguity at the weakest one:

• Layer 2 — tool description (the prompt). Spell out the canonical key; require the tool to echo what it resolved, so the model gets a self-correction signal in the same turn instead of re-deriving the key from scratch.
• Layer 3 — tool implementation. Canonicalize, then report the canonicalization. The canonicalization is usually already correct; the feedback is what's missing. That's the seam.
• Layer 4 — environment (identity, paths, config). A seam prompting cannot fix from inside; the tool must be loud so the model can see the mismatch instead of reasoning blind.

Live case study: the workflow tool

The merge queue keys by canonical repo name (ratchet2), but the repo parameter is polymorphic — name, path, or worktree path. The status action returns the literal text "no pending merge" whether the queue is empty or the model looked up a non-canonical key. That string is a false-negative-shaped answer: it reads as information when it's actually "you used the wrong key, silently."

The model didn't fail because it was sloppy. It failed because the tool left an ambiguous contract and a silent failure mode, and a bounded-context function resolved the ambiguity the wrong way.

Fix, layered:

• description — name the canonical key; require the tool to echo "looking up ratchet2".
• impl — resolveRepo already canonicalizes (rev-parse --show-toplevel + Base); it just doesn't report. One line prints the resolved key.
• environment — hostname says hq, machine.json says hq, but the journal files are home2-35a604.jsonl / c2mini-c4d100.jsonl. The home2→hq rename is half-applied. A tool that's loud about "I resolved repo X, wrote to journal Y" makes that mismatch visible instead of reasoning blind.

The punchline

Weights and training change the function. Prompting changes the contract. The contract is the cheap, high-leverage layer, and it's where this whole class of bug lives.

A sharper contract makes a dumber model deterministic. No amount of training makes an ambiguous contract deterministic.

ratchet/the-function-framework · corpus · 2026-10-24