An essay published this week at earendil.com hit #7 on HN with 415 points. The headline finding:
"The harness a model is called from dramatically impacts cost and quality."
— Databricks (from a benchmark of real-world coding agents against Databricks' own multi-million-line production codebase)
The specific result: Pi, a coding agent harness with 4 tools and a system prompt under 1,000 tokens, combined with Opus 4.8 achieved the highest overall pass rate in the benchmark — at more than 2× lower cost per task than Claude Code or Codex. Pi sent approximately 3× less context per turn. It managed context better, keeping a tighter working set and finishing tasks in fewer runs.
This is not a cherry-picked toy benchmark. This is Databricks — one of the most sophisticated AI engineering organizations in the world — running a real benchmark against their own production codebase. The result is clear: same model, different harness, different system prompt size, 2× cost reduction with equivalent output quality.
But the Databricks finding only explains half of the cost structure. The harness determines how much context the model receives per turn. The routing layer determines which model receives that context. Both matter. And the two savings stack.
The Uber lesson from earlier this year was about what happens when neither layer is optimized: 7.5-12.5× cost multiplier over the advertised seat price, budget exhausted by April.
The Databricks finding is about the first layer: optimizing the harness. Pi's 1,000-token system prompt versus Claude Code's significantly larger prompt means Pi sends 3× less context per turn. That 3× reduction applies to every call in an agentic loop — and agentic loops can run 20, 50, or 100 turns for complex tasks.
Consider a 50-turn agentic coding task:
At Opus 5 prices ($5.00/$25.00 per million tokens), that's approximately $1.75 in system prompt overhead savings per 50-turn task — just from the harness choice. At Claude Code usage patterns (multiple tasks per developer per day, dozens of developers), that compounds quickly.
But harness minimalism doesn't address the other cost variable: whether every one of those 50 turns actually needs Opus 5.
Consider the call types in a typical 50-turn coding agentic loop:
If 60% of turns route to a model that costs 15× less than Opus 5, and 30% of turns route to a model that costs 25× less than Opus 5, the blended cost reduction on those turns is roughly 17-20× from routing alone. Add the 3× reduction from harness minimalism, and the compounded reduction is 50-60× relative to a default all-Opus-5-with-Claude-Code baseline.
That's not a theoretical projection. It's the arithmetic of task-aware routing applied to the call distribution that Databricks' own study described.
Pi's architecture is explicitly minimal. 4 tools. Under 1,000 tokens of system prompt. Extensible via a shared bus (Shopify built pi-autoresearch by asking Pi to read its own extension documentation and build a new workflow). The Pi HN thread included a notable comment from a developer who observed:
"Versions of Pi are still shipping with model configs for certain inference providers. I do hope that gets decoupled at some stage."
That decoupling is exactly what a proxy layer provides. Pi's job is harness discipline: keep the system prompt tight, keep the tool surface minimal, finish tasks in fewer turns. Trimio's job is model routing: once Pi makes an API call, route it to the cheapest model that meets quality requirements for that specific call type.
The integration is one configuration change. Any Pi deployment that uses an OpenAI-compatible API endpoint adds one line:
OPENAI_BASE_URL=https://api.trimio.ai/v1Every API call Pi makes now routes through Trimio's proxy — getting cost attribution, LCR routing, and provider failover without Pi changing a single line of its own code. The harness handles its job; the routing layer handles its job. The savings from both stack.
The Databricks finding is not isolated. Earlier this year, a LangChain benchmark showed that changing only the agent harness — not the model — added 13.7 points to task completion. Same model, different harness context budget, different performance.
Both results point to the same underlying mechanic: the cost and quality of an agentic AI system is a function of two independent variables — how much context reaches the model per call (harness responsibility) and which model receives that context (routing layer responsibility). Both variables have significant leverage. Neither optimization is complete without the other.
The engineering teams that understand this relationship will build AI development infrastructure that is 50-100× cheaper than teams that default to max-context harnesses routing all calls to frontier models. That is not a marginal advantage — it is the difference between an AI development budget that scales with your team and one that blows past CFO projections by April.
If you're evaluating coding agent harnesses in 2026, the Databricks study gives you an empirical data point: Pi + quality-aware routing outperforms heavier harnesses on real production codebases at lower cost. The two evaluation criteria are:
The best harnesses are those that treat model selection as the routing layer's job, not the harness's job. Pi's community is already pushing for model config decoupling. When that happens, Pi becomes a first-class citizen in a routing-aware AI development stack.
Databricks ran a benchmark on their own production codebase and found that harness minimalism produces more than 2× cost reduction at equivalent quality. That's the first layer.
The second layer — routing the calls that harness minimalism makes more efficient to the cheapest model that can handle them — is where Trimio operates. Planning turns to frontier models. Execution turns to DeepSeek V4 Flash or Luna at 15-25× lower cost. Verification turns to the cheapest capable model in the table.
Neither layer is sufficient alone. A minimal harness that routes everything to Opus 5 leaves most of the routing savings on the table. An intelligent routing layer underneath a bloated harness captures routing savings but pays the context overhead on every call. The combination captures both.
Pi does the harness job. Trimio does the routing job. One configuration line makes them work together.
Trimio is the LLM proxy that routes every call in your agentic stack to the cheapest capable model — automatically, from behind any OpenAI-compatible harness. One URL change. No code migration. See how it works.