String runtime treats AI agents as first-class citizens
The quiet crisis of the AI agent era is not that these systems are dumb. It is that they are expensive in a way that has nothing to do with compute cost. Every time an agent reads a webpage, it pays for the entire page — the navigation menus, the cookie banners, the sidebars, the marketing copy, the seventeen paragraphs of fluff before the actual instruction. A human skims and ignores. A program calls only the functions it needs. But an agent, this new class of software user, has neither luxury. It re-reads everything, every turn, and pays again for every pixel of irrelevance. The bill arrives not in dollars but in context window, in latency, in the quiet degradation of judgment that comes from drowning in noise.
The Interface Nobody Designed
The problem is architectural, not behavioral. Every surface an agent touches was built for someone else. Websites are designed for human eyes that can filter, prioritize, and skip. Tool schemas are designed for programs that carry definitions without cost. The agent sits in between, a stranger in both houses, forced to pay for what it cannot use and to re-read what it has already seen. This is the insight at the heart of String, an open-source runtime that treats the agent not as a clever add-on to existing software, but as a first-class citizen deserving its own operating system. The team behind it, writing in a paper that landed on the arXiv preprint server in late August 2025, frames the problem in terms that feel almost obvious once stated: the interface is the bottleneck, and the interface was never built for the machine.
String’s answer is a radical simplification. Instead of forcing agents to navigate the messy, tangled web of human-oriented interfaces, it declares that every application is a single Markdown document. One file, written in a flavor the paper calls SFMD, declares the application’s views, its typed actions, its navigation structure, and its credentials. The runtime handles everything else — discovery, validation, execution, state, and secrets — behind two core verbs. `/open` to see, `/act` to do. That is the entire vocabulary. No plugins, no per-site integration, no fragile scraping pipelines. The web and the app turn out to be two renderings of one architecture: an SFMD site serves styled HTML to browsers and the raw document to agents. One grammar reaches apps, files, shells, and even legacy HTML, with no per-site integration required.
The Cost of Telling Too Much
The most striking finding in the paper is not about what the system can do, but about what happens when it is done badly. The team discovered that views must stay partial by design, and the staging of information is causal. Disclosing one tier of detail a single turn too early costs up to 23 accuracy points. That is not a minor optimization. That is the difference between a system that works and a system that fails, determined solely by when information arrives. Proper staging, the paper reports, drops wrong-action selection from 28% to 2%. The implications ripple far beyond String itself. Every AI assistant that dumps an entire document into context on the first turn is actively sabotaging its own performance. The machine needs information the way a conversation needs pacing — too much too soon, and the whole thing collapses into confusion.
This finding resonates with a broader pattern that has emerged from practical experience in the field. A developer who wired agentic coding tools to a Kanban board, writing about the experience for The New York Times, described a similar revelation: the agent’s performance improved dramatically not when the model got smarter, but when the interface got cleaner. The Kanban board, with its strict columns and limited card content, forced the agent to see only what was relevant to the current task. The tool was not the bottleneck. The information architecture was. String’s contribution is to systematize this intuition, to turn a developer’s lucky discovery into a design principle with measurable consequences.
Privilege Follows Provenance
Security in
String is handled with a principle that sounds simple but represents a fundamental shift in how we think about agent permissions. Privilege follows provenance. A remote page may call HTTP but never the shell. Caller-supplied text never expands a stored secret. This is not a feature list; it is a statement about trust. In the current landscape, agents are given broad permissions and then told to be careful. String inverts this: the system itself enforces what each piece of the application can do, based on where it came from. The remote page cannot touch the local filesystem. The user’s input cannot leak into credentials. The boundary is enforced by the runtime, not by the agent’s judgment, which is exactly where it belongs.
The results of the evaluation are sobering in their modesty and impressive in their consistency. On an 87-task benchmark that pairs each task with curated skills, operationalizing those procedures as on-demand String apps yields comparable aggregate success across six models, from frontier to small, at +1.3 percentage points. The paper, available on arXiv, provides the full methodology and per-model breakdowns for independent verification. The headline number, though, is the token savings: 33.5% fewer tokens among completed episodes. The resident interface stays a constant 53 tokens at any catalog size. That last figure deserves attention. Fifty-three tokens. A single sentence. That is the entire overhead of the interface, regardless of whether the catalog contains ten apps or ten thousand. The agent pays for what it sees, not for what exists.
The Gap Between Practice and Promise
Three months of production use taught the team things that benchmarks cannot capture. The paper reports these lessons in a tone that is refreshingly free of triumphalism. Real users do not think in terms of SFMD documents; they think in terms of tasks. The system works best when the Markdown files are treated as living artifacts, updated as the workflow evolves, rather than as static specifications. And the biggest surprise: the hardest part is not building the apps, but deciding what to leave out of them. The discipline of partial views, of staging information in the right order, turns out to be a design skill that does not come naturally to developers accustomed to building for humans.
This is where the gap between practice and promise becomes visible. The paper describes a system that works, with numbers to back it up. But the numbers also reveal how far we are from a world where agents are truly useful. The benchmark tasks are paired with curated skills — a condition that does not exist in the wild. The 33.5% token savings applies to completed episodes, which means the system still fails often enough that the savings are partial. And the constant 53-token interface is elegant, but it only works if someone has written the SFMD document in the first place. The promise is real. The practice is still catching up.
The deeper lesson, the one that lingers after the technical details fade, is about attention itself. We have spent two decades building interfaces that demand attention — bright colors, notifications, infinite scrolls, autoplaying videos. We optimized for engagement, which is to say, for capture. The agent, this new user, has no such vulnerability. It cannot be distracted, but it also cannot filter. It pays for everything it sees, and it sees everything. String’s insight is that the solution is not to make the agent smarter, but to make the world it sees smaller. The machine does not need more information. It needs less, in the right order, at the right time. That is a lesson for human interfaces too, if we are willing to learn it.