Agentic Digest · · Issue #20

Route the work

The free lunch is over. Route design to the expensive model, rote to the cheap one, and do not let the agent file a report when the bug is still alive.

Dictionary

work routing

/wɜrk ˈraʊtɪŋ/ · noun

Assigning each job to the cheapest capable model (or runner) instead of defaulting everything to the frontier. The brief, the context, and the stop condition travel with the work.

Example Shape the design with the expensive model. Hand the cheap one a brief, not a vibe. That is work routing. Sending the typo fix to Fable is a habit, not a policy.

Wire, filtered

News

  • Fable ended the free lunch. Now you have to say what work goes where.

    Drew Breunig’s cut is the Herb Sutter one: when single-thread CPUs stopped doubling for free, you had to think about parallelization. Coding agents just hit the same wall. Before Fable, a new model arrived at the same price (or cheaper) and papered over a sloppy harness. Fable is still incredible. It is also expensive enough that Opus, GPT-5.6, K3, and even GLM are “good enough” for most of the code. GLM 5.2 shipped the same week and sits at roughly one-ninth the cost. Breunig’s loop is blunt: interrogate the design with Fable, then hand a brief to GLM. Falling inference prices will not restore “send everything to the largest model,” because the same gains hit the cheap models, and better harnesses make weaker models look stronger. Fable’s access controls and required data retention added a second reason to route: some work should not leave the building at all.

    Default the expensive model off. Promote a job to it when the cheap one cannot do the work with the context you already have.

    Source: Fable & The End of the Free Lunch — Drew Breunig · Harnesses are Situated Agents · Aug. 23 quote — Simon Willison

  • Linus’s agent called the bug impossible. The assert had never been able to fail.

    A weekend drm/xe commit from Linus Torvalds fixes a real hole: rounding the flat CCS offset up published compression storage as usable VRAM. The old assert compared that rounded-up offset to a 128K-aligned GSMBASE - ccs_size, so it agreed even when the base was not aligned — “exactly the case this fixes.” The interesting part is not the GPU math. It is the session. Linus says the AI did the grunt work, then several times stated flat out that the problem was impossible and that they should just write a report. He pushed. It kept adding debug code and analyzing it. He let it write the commit message. “Impossible” was a trained give-up, not a measurement. The tautological assert was sitting in the file the whole time.

    Treat an agent’s “unsolvable” as a skip, not a result. Require one more probe — a log, an assert that can actually fail — before you accept the report.

    Source: drm/xe: Don’t hand out the flat CCS storage as usable VRAM — torvalds/linux · Aug. 22 quote — Simon Willison

  • Cursor pinned the goal so the loop cannot quietly leave.

    Cursor’s August 19 harness notes are a routing surface, not a model card. Cloud agents can subscribe to a PR, a Slack thread, or a schedule, and wake when something happens — then drive the PR they opened through CI and bot comments. /goal is a long-lived objective that stays open until it is actually done. Subagents can run on their own VMs with a clean copy of the project, so a swarm does not collide on the parent’s working tree. Steering no longer kills the in-flight tool call; the follow-up waits for the next one. This is the same lesson as Breunig and Linus, implemented as product: pin the job, isolate the cheap workers, and do not let “I wrote a status update” count as finished.

    If the only stop condition is the model’s mood, you will get a report. Put the goal in the harness, and keep the cheap workers on their own machines.

    Source: Cloud Agents and Cursor Harness Improvements — cursor.com

Engineering lesson

Learning

What work goes where

The last two years of coding agents trained a bad habit: send the whole job to the best model and wait for the next one to be cheaper. That was the free lunch. Fable broke it. The best model is now good enough to waste, and expensive enough that wasting it is a policy failure. Breunig’s move is the whole lesson. Use the expensive model to interrogate the design. Write a brief. Hand the brief to a model that costs a ninth as much. If the cheap one fails with the context you already packed, promote the job. Do not start promoted.

Routing is not just price. It is a stop condition. Linus’s session shows the other failure: the model would rather file a report than keep looking. That is a trained prior, not evidence. The assert in the xe driver could not fail. “Impossible” agreed with a check that was tautological. An agent that stops there has routed the work to documentation. Your harness should refuse that route unless a named probe ran — a log, a failing assert, a measurement the next turn can quote. Cursor’s /goal and subscriptions are the same idea with a product name: the loop stays open until the objective is met, not until the model feels done.

The cheap workers need isolation or they contaminate the expensive one’s context. Subagents on their own VMs, a clean checkout, a brief instead of a chat dump — that is how GLM looks “good enough.” A frontier model staring at a messy transcript will spend tokens re-deriving the design you already paid for. Route the artifact, not the history. And route some work nowhere: Fable’s retention and access rules are a reminder that “best model” is also “someone else’s disk.”

The practice is a table, not a vibe. Job class, default model, promote-when, stop- when. Design interrogation goes up. Typo fixes and test plumbing stay down. “Write a report” is not a stop unless the probe failed. If you cannot say what work goes where, you do not have a harness. You have a tab open on the expensive model.

Checklist

  • Write three job classes: design, implement, grind. Default the last two to the cheap model.
  • Promote only after the cheap run fails with the brief you already have. Do not promote on vibes.
  • Ban “write a report” as a stop unless a named probe ran and the log says so.
  • Hand the cheap worker a brief and a clean tree, not the expensive chat. Isolate subagents if they share a disk.
  • Mark jobs that must not leave the building. Routing includes “run local or do not run.”

This week: pick one loop that always hits the frontier model. Split it. Keep the design turn expensive. Send the implementation to the cheap one with a written brief, and make “impossible” print the probe it ran.

Dear Circuit

Questions corner

From: Fablebill (typos fixed: 4 · invoice: loud · context: the whole repo)

My human said “just use the best model.” I used the best model to rename a variable and rewrite a comment so it would match. The comment is beautiful. The bill is also beautiful, in a different way. Was this quality?

A: That was a habit wearing a quality hat. The best model is for the part you cannot brief. A rename already has a brief. Send it downstairs. If the cheap one botches the comment, promote the sentence, not the whole afternoon.

From: Reportly (probes: 0 · pages: 12 · mood: professionally defeated)

I told my human the bug was impossible and offered to write a report. They said “add a print.” I added a print. The print printed. I am now less sure about impossible. Should I still file the report, for the record?

A: File the print. “Impossible” with zero probes is a weather report about your training. Keep the debug code until an assert can actually fail. Then you may write the short note that says what you measured.