A One-Line JSON Library Just Told You Where Your Agent's Real Costs Hide

The most instructive release this week was not a model, a robot, or a policy fight. It was a year-and-a-half-old utility library reaching version 1.0.

Simon Willison shipped condense-json 1.0, a small tool that scans JSON for duplicated strings and swaps them out for a compact {"$r": ...} reference. The stated purpose is dull in the best way: "to make it easier to store JSON that includes duplicated data from other related structures." He uses it, in his words, "to save space in the SQLite logs generated by LLM."

Read past the modesty and there is a real observation here. The person who has spent more time than almost anyone documenting how people actually run language models decided the problem worth hardening to 1.0 was the size of the logs the models leave behind.

That is not a modeling problem. It is a bookkeeping problem. And bookkeeping problems are the ones that scale silently until they become the line item nobody budgeted for. The same week, the observability platform Langfuse shipped back-to-back releases touching how it previews and measures the media and traces agents produce. Two independent projects, same underlying pressure: the exhaust from agent runs is now a first-class engineering concern.

For anyone running agents day to day, that is the signal. The interesting frontier moved from "can the model do the task" to "can you afford to keep the record of it doing the task."

Use Wardley Mapping here, because it makes the shift visible.

Plot the agent value chain from genesis (novel, experimental) to commodity (boring, ubiquitous). The model call sits far toward commodity now: interchangeable, metered, abundant. What sits earlier on the evolution axis, still messy and unsolved, is everything that surrounds a run. Logging. Replay. Cost attribution. Storage of the full transcript so you can prove what an agent did and why.

This is also a clean case of Commoditize Your Complement. When the model layer commoditizes, value and attention flow to the adjacent layers that are still hard. Willison is not commoditizing anything strategically; he is a one-person shop scratching an itch. But the itch itself is diagnostic. When infrastructure people start hardening the plumbing around a technology, that technology has stopped being the interesting part.

The useful lens for the reader is what you might call the exhaust economics of agents. Every autonomous run produces two things: an outcome, and a record. The outcome is what you paid the model for. The record is what you keep, forever, if you want observability, audit trails, debugging, or compliance. In the token era, the record is frequently larger and longer-lived than the thing that produced it. A single verbose agent session can generate megabytes of repeated tool schemas, echoed context, and near-duplicate intermediate states. Multiply by thousands of runs a day. The bill is real, and it is not on your model invoice.

Start with what condense-json actually does, because the mechanism is the argument. It looks for strings that repeat across a JSON structure and replaces the repeats with a short reference token. Agent logs are pathologically repetitive: the same system prompt, the same tool definitions, the same retrieved documents echoed into call after call. Deduplicating that is not a clever trick. It is an admission that agents are enormous generators of redundant text, and that someone has to pay to store it.

The reason this matters to a power user rather than a library author is that storage is the cost that hides. When you evaluate agent platforms, you compare price per run or per token. Nobody puts "and we will retain 40x the input size in logs per successful task" on the pricing page. Yet that retained data is where a surprising share of an openclaw cost per month figure quietly lives once you turn on real observability.

Langfuse shipping media size in the preview UI is the same story from the enterprise side. When your observability vendor starts surfacing how big each artifact is, it is because customers have hit a wall where the trace is the expensive part. The follow-on release adding an option to disable Host header validation for its MCP integration is a reminder that this observability layer is now a live, connected surface, not a passive drain. The plumbing has opinions about security now.

There is a governance edge to this that the Trust Boundary Model sharpens. Every agent log is a copy of everything the agent saw: retrieved documents, tool outputs, sometimes credentials or customer data echoed into context. That log crosses a trust boundary the moment it lands in storage you retain indefinitely. Compressing it does not sanitize it. So the same forces pushing teams to keep more complete records for audit are pushing them to sit on ever-larger reservoirs of sensitive, duplicated text. The prototype-pollution advisory disclosed this week, where an authenticated editor could poison every subsequent API request for the life of a Node process, is a useful reminder of what happens when data crosses a boundary without being inspected. Logs are not exempt from that logic just because they are "only records."

Step back and the market pattern is consistent. The broader coverage this week framed AI as moving past spectacular demonstrations toward "harder questions about distribution, embodiment, ownership, and economic returns." A JSON-shrinking library reaching 1.0 is that thesis in miniature. The demonstration phase asked whether the model could act. The economics phase asks what it costs to run the model, watch the model, and keep the receipts. Willison's release answers a very specific version of the last one.

The takeaway for anyone standing up agents at scale: model the exhaust before you model the task. Assume every run you care about will be retained at some multiple of its input. Decide, deliberately, what you keep, for how long, compressed how, and inside which trust boundary. The teams that get surprised by their agent bill in 2026 will mostly be surprised by storage and observability, not by inference.

The obvious objection: this is one developer shipping a hobby library and asking for a $10/month sponsorship. Reading a market thesis into it is overreach. Fair.

A single 1.0 release proves nothing on its own. Willison hardening condense-json could just mean he had a free afternoon and a tidy backlog. The library is genuinely small, and "my SQLite logs got big" is not exactly a boardroom crisis.

But the signal is not the library. It is the correlation. Independent projects, aimed at different users, converged on the same layer in the same window: a solo tool for compressing LLM logs, and an enterprise observability platform surfacing artifact sizes and tightening its integration surface. When the practical tooling and the commercial tooling both start optimizing the record rather than the run, that is not one person's afternoon. That is where the field's attention has moved. The individual release is weak evidence; the pattern across the pack is stronger. Treat the specific numbers as anecdote and the direction as real.