Less Harness, More Agent

Mario Zechner, the founder of libGDX, shipped a coding agent with four tools and a system prompt under 200 tokens. Databricks ran an internal benchmark on it and found that simple harnesses like this cut the cost per task by roughly half at equal quality. Shopify used the same agent to make its Liquid templating 53 percent faster.

The industry spent two years adding things to agents. The most efficient agent on the market right now is the one that removed almost everything.

The Instruction Book You Always Carry

Every AI agent you have ever used runs on a system prompt. That’s the instruction book the model reads before every single response. It defines the role, the rules, the tools available, and the boundaries. You never see it, but it sits in the context on every request, from the first word to the last.

The system prompt isn’t static though. Every tool you connect, every capability you enable, adds pages to that book. The agent carries the whole book on every turn, always, and pays for all of it, even when a single page would do. If Uncle Ben had been an AI engineer, he would have said: with great power comes great context overhead.

That’s the mechanism behind the trend I described last week in When the Model Is Free, the Harness Is the Business. When models cost almost nothing, the software around them decides who wins. The harness is that software. It handles tool calls, memory, permissions, and the loop that turns a language model into a worker instead of a chat box.

The Accumulation Phase

Modern harnesses started small and grew fast. MCP clients, subagents, permissions, scheduling, notifications, remote execution. Every release added a feature, and every feature made sense on its own.

Features win demos. Nobody ever lost a pitch by showing too many capabilities. The cost of a feature is invisible at demo time, because the bill arrives later, one small charge per request, forever.

This is how you end up with an agent that has forty tools and uses three. The three get the work done. The other thirty-seven sit in the system prompt, inflating every single request the agent makes.

The Tax You Pay on Every Turn

Here’s the detail that changes how you read every vendor slide. When you connect a tool to an agent, the harness injects the tool’s schema into the system prompt. Name, description, input fields, all of it. That stays in context on every request, even when the agent never calls that tool.

A single tool costs a few hundred tokens per request. Ten tools cost thousands, permanently, whether you use them or not. The cost shows up in three places: more tokens per request, more latency, and less attention left for the actual task.

Run the math on a working agent. Ten tools at roughly four hundred tokens of schema each, forty requests per hour, eight hours a day. That’s over a hundred thousand tokens of pure overhead every day, spent on tools the agent may never call. The models are cheap now, but the waste isn’t just money. Every one of those tokens competes with the actual task for the model’s attention window.

I’ve kept the MCP servers in my own setups at the minimum for exactly this reason. Every server you add is more context than you sometimes need. The model starts considering capabilities that have nothing to do with the question in front of it, and that’s where mistakes creep in.

Pi: The Smallest Serious Agent

Pi, Zechner’s agent, ships with four native tools. Read, write, edit, bash. That’s the entire core. Everything else is a plugin you add explicitly, only when you need it, and only for as long as you need it.

The system prompt stays around 200 tokens. The agent knows exactly what it can do, and what it can do is deliberately small. Zechner rebuilt his whole stack around one principle: knowing exactly what hits the context window, and controlling it.

The Databricks benchmark is the part enterprises should care about. At equal quality, the minimal harness cost about half per task. The savings came from the harness skipping forty tools it never touched.

The Market Is Learning to Subtract

The interesting signal is that the heavyweights are moving in the same direction. Claude Code and Codex have both been trimming their defaults, pushing capabilities into plugins and skills you opt into. The market is converging on the same lesson: the always-loaded context is a budget, and every feature spends from it.

This is the opposite of the enterprise instinct. In the ERP world, the reflex is to buy the suite with everything included, because “you never know when you might need it.” The agent world just measured that instinct and found it costs twice as much for the same result.

What This Looks Like in an ERP

Take a concrete flow. An operator asks the agent whether the company can promise a customer 120 units of SKU X for the twentieth of the month. Simple question. It needs three things: open orders, current stock, and production capacity.

Connect eight modules, because the vendor sells a suite: orders, inventory, production, invoicing, master data, BI, CRM, and HR. Now every request, including the simple one, carries eight schemas. The model must pick the right tool among eight. It can reach for BI when the answer sits in inventory, and it will, regularly. It can also check your employees’ vacation days, just in case you asked about a pallet.

Connect three modules instead. Orders, inventory, production. The context is lighter, the choice is obvious, the answer comes back faster, and the model spends its attention on the stock level instead of deciding which of eight departments to interrogate.

Nothing was lost. The other five modules still exist. They are just not standing in the middle of every conversation, charging rent.

The Rule

The question for any agent project is what must be loaded for this task to run. Keep the core small, add everything else on demand, and remove what you aren’t using.

Your agent should carry a toolbox, not a warehouse. The capabilities you need are one explicit plugin away. The capabilities you load by default are a tax you pay on every single request, forever.

The winning harness loads exactly what the task in front of it requires, and nothing more.

Written by Andrea Guaccio 

September 01, 2026