A Four-Tier Routing Harness for Coding Agents: How Grist Cuts Token Costs Without Sacrificing Quality

Three independent projects dropped this week that, taken together, sketch a practical blueprint for production coding agents: tiered model routing, token compression inside each tier, and open-source guardrails. The clearest example is Grist, a coding harness built on Opencode v2 that routes tasks across four cost tiers while applying the Sol-Pi methodology to cut tokens within every tier.

The pattern

Grist's core idea is simple: not every coding task deserves a frontier model. The harness classifies each incoming task into one of four rungs (easy, medium, hard, frontier) using the Jev model as a router, then dispatches to the cheapest model capable of handling that rung. Easy tasks go to DeepSeek-class models; only genuinely hard tasks reach something like Opus 5.5.

This is not a new concept in theory, but Grist is one of the first public implementations that wires classification, dispatch, and token compression into a single open-source harness rather than leaving each piece as an exercise for the reader.

Why now

Two things converged to make this tractable. First, Opencode v2 provides a stable programmatic layer for multi-model dispatch, removing the plumbing work that previously made routing harnesses painful to build. Second, the Sol-Pi paper introduced action fusion and observation packing, techniques that compress the token footprint of agentic loops by merging redundant tool calls and packing environment observations more densely. Applied per tier, these cuts stack on top of the routing savings rather than replacing them.

A parallel open-source guardrail tool also surfaced this week, also Jev-powered, aimed at safety and compliance checks in production LLM deployments. And a loopback proxy for Claude Code offers a lighter-weight option for teams who just want to intercept, reroute, and observe model calls without a full harness. The three projects did not coordinate, but they point at the same emerging agent tooling stack.

How it works in practice

1. Classify first. Jev scores each task and assigns it to a rung. The quality of this classification step determines most of your savings. Invest in evaluation data for your specific domain before assuming the default classifier generalizes.
2. Dispatch by rung. Easy and medium tasks go to cheaper models. Hard and frontier tasks escalate. Grist's four-rung split is a reasonable starting point, but two or three tiers may be sufficient for narrower domains.
3. Apply Sol-Pi inside each tier. Action fusion merges tool calls that can be batched; observation packing condenses environment state before it hits the context window. These are prompt-level and scaffolding-level changes, not model changes, so they apply regardless of which model you dispatched to.
4. Add a guardrail layer. The Jev-powered guardrail project slots in as a pre- or post-generation filter. For coding agents, the most useful checks are output safety (no credential leakage, no destructive shell commands) and schema compliance.
5. Observe with a proxy. The Claude Code loopback proxy pattern is worth adopting even if you are not using Claude. Intercepting model calls at the proxy layer gives you routing visibility and lets you A/B test tier boundaries without changing application code.

The trade-off

Tiered routing introduces a new failure mode: misclassification. A task routed to the wrong tier either wastes money (over-routed to frontier) or produces a degraded result (under-routed to cheap). Grist mitigates this with a hard escalation path, but the classification model itself is a new dependency with its own latency and cost. Teams with low-volume, high-stakes workloads may find the overhead of classification exceeds the savings. The approach pays off most clearly at scale, where even a 10-percent misclassification rate is acceptable if the 90-percent correct cases generate meaningful savings.

The Sol-Pi methodology also requires careful implementation. Action fusion can break agents that depend on intermediate observation state between tool calls. Test against your existing eval suite before enabling it in production.

Where it goes next

The logical next step is dynamic tier boundaries: letting the router adjust rung thresholds based on observed output quality rather than static rules. A feedback loop that bumps a task up a tier when the lower-tier model's output fails a quality check would make the harness self-correcting. None of the current tools do this automatically, but the proxy-and-guardrail layer that is already emerging provides the instrumentation needed to build it.

Expect model routing to become a first-class concern in agent frameworks over the next few months, the same way caching and batching became standard optimizations in back in earlier LLM infrastructure cycles.

The signal here is not any single tool. It is that open-source agent infrastructure is maturing fast enough that a solo builder can now ship a four-tier routing harness with guardrails in a weekend.