Appearance
How I built the EAS prompt
The EAS voice agent's behavior comes from one large system prompt, compiled by the Blueprint platform from modular variables and module bodies. This section is the record of how that prompt got rebuilt: what was wrong with the one I inherited, what replaced the patching loop, and how a change is proven before it ships.
It's written as a narrative because the method is the transferable part. The maxims and cases are EAS's; the shape of the loop isn't.
The problem with the prompt I inherited
The shipped prompt was effective and large. It encoded a great deal of fixed control flow (ordering rules, guard conditions, output scripts) in English prose, which meant edits rippled unpredictably and rules could quietly contradict each other. A prompt that says "never call availability until lookup has run" in one section and gates availability on year/make/model in another isn't stating two rules. It's stating one accidental rule, and nobody can see which.
The daily call reviews (Daily Reports) made the cost concrete rather than theoretical:
- Rigid slot-filling lost ready-to-book callers. A first-time customer asked "any availability tomorrow?" and was refused an answer until he produced year/make/model. He hung up at 1:05.
- The quote path had no capture. A labor-rate shopper got the same inspection pitch through seven exchanges and left with "That sounds really shady."
- Drop-off/waiter choices were presented without their consequences, so callers chose between options they didn't understand, or hit a wall and got nothing.
Patching prose against each of these individually is how the prompt got large in the first place. In June 2026 we got the go-ahead to rework it from first principles instead.
The method
Four artifacts, in dependency order. Each exists because the previous one wasn't sufficient alone.
1. Maxims: the spec of record
Plain-language rules built point by point from observed calls. The inversion that matters: prompt text is compiled from the maxims, not the other way around. When behavior is wrong, the maxim changes first and the prompt follows. That's what stops the prose drifting back into accretion.
Each maxim names the current-prompt rule it displaces, so the rework is auditable against what it replaced rather than being a fresh start that quietly drops working behavior. M3 displaces two rules at once and is the load-bearing one: availability doesn't depend on the vehicle, so the "no availability until year/make/model" gate was false, and removing it is what lets availability go first.
2. Tabletop: the dry run
Nineteen real calls from the daily reports, walked turn by turn against the maxims to find gaps without spending a live test. Selection is deliberately biased toward calls where the prompt determined the outcome; platform failures are excluded except where the prompt's degradation behavior is itself the question. Controls are included so the rework can be checked for regressions, not just fixes.
The tabletop's real output is the list of places the maxims are silent. Those are gaps to fix in the spec, not judgment calls to improvise at runtime. Two showed up immediately: what the agent says when a tool contradicts the caller's own evidence, and how to handle a quote request for work the shop already inspected.
3. Call flow: the structural read
A decision-tree of a call with every node classed as deterministic routing or genuine language judgment. This is what turned "the prompt feels too big" into a measurement: roughly two-thirds of a call is deterministic control flow, and it's exactly the two-thirds the prompt is largest and most repetitive about.
That finding is why the rework is a reordering rather than a rewrite. It also produced a platform-level argument that outlives both EAS and AutoOps, so that half lives in the Avoca tree: Rigid vs LLM: where the boundary sits.
4. Regression corpus: the gate
Every case is anchored to a real call where the agent failed, or to a behavior we decided on deliberately. When the prompt changes, the corpus re-runs, so a fix in one place can't silently regress another. This is the cheap gate that runs before Hamming, not instead of it.
Cases are created from real calls via the annotate-call skill: give it a call id, it pulls the transcript, annotates it against a fixed schema (category, severity 0–5, frequency), and writes the case for review.
The part worth stealing is the fidelity ladder, because it keeps the corpus honest about what it has actually proven:
| Fidelity | What it does | What it proves |
|---|---|---|
| desk-check | Reason through what the prompt directs at the trigger | The logic is right. Not that the model obeys it. |
| model-replay | Run the compiled prompt as system, replay caller turns, read the real generation | The model actually follows the direction |
| hamming | Voice-level regression | The real gate |
A case isn't "fixed" until at least model-replay confirms it. A desk-check PASS is a claim about the prompt, not about the agent, and conflating those two is how a prompt rework convinces itself it's finished.
Verdicts are PASS / PARTIAL / GAP. PARTIAL is load-bearing: it means the core failure is fixed but an edge is still undefined, which is a different thing from working.
Where it stands
The corpus has grown past the original tabletop set as live calls surface new failures. The maxims remain the spec, the prompt is compiled from them, and each version is graded against the corpus before it goes near a live call.
The honest state: most cases sit at desk-check fidelity, meaning the logic has been reasoned through but not proven against real generations. Case 05 (tool-contradiction recovery) is still a GAP. The maxims have no defined behavior at that trigger, which is exactly what the tabletop predicted in June and what hasn't been closed since.
Related
- Prompt changelog — version-by-version record of shipped edits
- Architecture: In-Call Sequence — the runtime loop the prompt executes inside
- Rigid vs LLM: where the boundary sits — the platform-level argument this work produced