Waiting Taxes the Swarm

If You Only Read One Thing

A test suite can raise an agent’s inference bill while the model does no new reasoning. Long Tests Reprice Agents follows the cache lifetime behind that surprise; Nimble Learns the Difference examines a small model trained for narrow judgments. Together they expose two overlooked costs: repeatedly rebuilding working context, and paying a general conversational model to make a bounded decision.

Nimble Learns the Difference

A small decision model now comes with a recipe for teaching it which detail should change its answer. Bespoke Labs’ September 18 Nimble release makes that recipe inspectable and runnable locally. The useful advance is the combination of weights, training procedure and comparison with the untuned model.

September 17’s Jev story explained the appeal of answering a bounded question without generating a paragraph. Nimble takes the next step: its published adapter modifies Qwen3.5-9B to score permitted answers directly. Software assembles the result from those scores. There is no generated explanation or JSON document to repair.

The training idea is contrastive examples: think of two nearly identical expense claims, one authorized and one unauthorized. Change the decisive evidence while preserving the surrounding language, then train the model to change its verdict. This makes the exercise about sensitivity to the rule rather than recognition of the topic. The practical handle is simple: the difference must matter.

Bespoke trained on 2,676 examples. Its saved comparison reports 292 reference-label matches out of 324 for Nimble, versus 215 for the base model and 302 for Jev. That is a substantial improvement within this test. It is not evidence that a local model can replace Jev across arbitrary policies.

The strongest limitation sits inside the denominator. Those 324 examples form 162 closely related pairs from six source families, and the reference labels are synthetic, without human review. The comparison establishes agreement with the dataset’s answers; errors shared by the generator and checker could survive it. Bespoke also distinguishes its checked adapter execution from the merged model used in the local quickstart, which lacks a separate quality test.

For an existing multi-model workflow, this adds a possible adaptation layer beneath the expensive reviewer. A bounded routing or rubric decision can have its own training examples and acceptance test. That extends independent review by making the decision boundary trainable; it does not establish that review can safely disappear.

The serving contract keeps the scope narrow: flat choices, no more than 2,048 prompt tokens, and no free-form answers. The decisive next result is agreement on independently human-labeled, out-of-domain cases, including cases where none of the supplied choices fits.

Long Tests Reprice Agents

Parallel coding agents can spend heavily on reconstructing context while waiting for tests. A September 19 practitioner report gives that failure mode a measurable shape, and Anthropic’s documentation confirms the mechanism. The lesson extends worktree orchestration: task duration affects inference economics even when the model and assignment stay fixed.

A prompt cache stores the model’s already-processed input so later requests can reuse it. Think of leaving a large document open between consultations. If that working state expires, the next consultation must process the document again. The relevant clock is the gap between requests, including time spent waiting on a build. A quiet agent can therefore return with a large input charge.

Claude Code’s documented defaults give the main conversation a one-hour cache during included subscription usage. Sub-agents normally receive five minutes. Each child has its own conversation and cache; the parent’s longer lifetime does not extend it. In Claude Code 2.1.242 or later, the setting subagentPromptCacheTtl: "1h" changes that boundary, unless an environment override takes precedence.

In the operator’s before/after account, five sub-agents generated 12.2 million cache-write tokens before the change. Five comparable sub-agents afterward generated 3.0 million over roughly 530 turns: about 75% fewer writes. One review agent reportedly completed 147 turns over eighty minutes without a full rewrite. These are self-reported observational measurements, not a randomized workload comparison or a demonstrated 75% subscription saving.

The trade-off is real. Anthropic’s cost explanation prices five-minute cache writes at 1.25 times ordinary input and one-hour writes at twice ordinary input. A short-lived worker pays the higher write rate without benefiting from the extra lifetime. A worker repeatedly blocked beyond five minutes has a different calculation. Subscription quota weights cannot simply be inferred from API prices.

The reproducible practice is to classify the expensive misses before changing the lifetime. Child-session transcripts record cache writes in separate five-minute and one-hour fields, making the switch observable. Expiration calls for a different response from a changed request prefix, which a longer clock cannot preserve. The operator reports both failure types.

This advances September 16’s context-budget discussion from what a worker inherits to what it must process again. The payoff condition is fewer repeated full-context writes on matched test-heavy tasks, with unchanged completion quality and lower total weighted input cost.

The Contrarian Take

Everyone says: Cheap decision models make continuous agent review cheap enough to run everywhere.

Here’s why that’s incomplete: The reviewer’s inference bill is only the first cost. Abide’s published replay, examined below, had another model confirm just 10 of 39 edit-level flags, compared with 11 of 15 turn-level flags. The two phases checked different rules, so this does not isolate a timing effect. A false alert can send an otherwise useful agent into unnecessary repair work. Nimble’s synthetic-label score likewise measures one bounded decision task, not the cost of mistakes downstream. The economic question is whether a check prevents more work than its false alarms create; cheap judgment still needs an appropriate moment to judge.

Under the Radar

Turn-level flags survived review more often. Abide’s September 18 replay covers 93 Claude Code sessions and 147 turns. A separate Claude reviewer confirmed 11 of 15 turn flags, versus 10 of 39 edit flags. This extends the recent instruction-loading story: loading rules is only the first step toward useful review. Different rules ran at each phase, so timing alone cannot explain the gap. The model-based review also leaves actual repair success unmeasured.
An invisible session can make the quota display misleading. Agent Sessions 5.5, released September 19, makes Codex quota discovery honor the configured session directory and inherited CODEX_HOME. Previously, discovery assumed the default location. This matters to isolated agent setups: moving sessions can change what the monitor sees without changing consumption. A GUI launch still may not inherit a shell-only environment variable, so the app’s explicit directory override remains a separate configuration boundary. The fix improves discovery, not the provider’s underlying accounting.

Quick Takes

Step 5 Preview earns attention before a migration. Artificial Analysis dates StepFun’s new evaluation to September 18 and reports an Intelligence Index score of 44 at roughly 100 output tokens per second, with $1 input and $2.70 output pricing per million tokens. Its 160 million evaluation output tokens complicate the cheap-token story. Evaluator access through StepFun establishes a testable model; it does not by itself establish unrestricted customer availability. (Source)
Muse gives integrations an admission process. Meta’s Muse Connector Platform accepts submissions and describes functional, security and legal review plus end-to-end testing before directory placement. Stripe Link supplies the payment integration. The developer consequence is a new route into agent-mediated tasks, with approval between an integration and user discovery. The public page establishes that process; it supplies no completion-rate evidence for the resulting workflows. (Source)
Ollama starts exposing the thinking default. September 19’s 0.34.3-rc1 release candidate adds model metadata listing supported thinking levels and their default. That lets clients discover a model’s controls instead of applying one generic effort switch. This extends August 23’s effort-setting warning into an interface improvement. It remains a release candidate, and metadata about available settings cannot say which setting performs best. (Source)

The Thread

The placement of a decision changes its economics. Nimble puts a bounded judgment into a trainable local component. The cache report shows a test suite delaying the next model request long enough to trigger repeated input processing. Abide raises a related testing question: would the same rule produce better alerts on a completed turn? Its replay compares different rules, so it cannot settle that question. These are distinct mechanisms, but each makes workflow scheduling part of model evaluation.

That adds a question to model selection: at what point does this component have enough evidence to earn its cost? A fast classifier belongs where the choices are already defined. A semantic reviewer may need a complete change. A coding worker waiting for tests needs retained context more than another reasoning step. The useful division of work follows those conditions; assigning the strongest model to every stage leaves them unresolved.

Predictions

I predict: Ollama will include the model-specific thinking controls and default in a stable release by October 4. The feature already exists in its September 19 release candidate, giving this forecast an owned implementation milestone. This predicts availability, not improved model accuracy. (Confidence: medium; Check by: 2026-10-04)

Issue date: September 20, 2026. Generated at 03:41 AM ET.