The model is the cheap part now

Hey there 👋

I sat down this week to find the smartest new model and kept landing on the plumbing instead. I opened Microsoft’s harness release expecting model news, and the model is barely in it. I read a finance launch that was mostly about a graph and an approval table, not a bigger brain. Even the price story pointed the same way: the top-tier reasoning model held its price while the everyday workhorse got 80% cheaper.

Put a week of that together and it stops being a coincidence. The thing that changed how an agent behaves this week was almost never the model. It was the runtime wrapped around it, the part that decides what the agent can touch, when it stops, and whether it did the same thing twice. So today is a runtime issue. Here is what shipped, and why the boring layer is where the real gains went.

Ron

The Big Thing

Microsoft’s agent runtime went GA, and the model is the small part.

Microsoft moved its Agent Framework past the SDK stage and into a supported production runtime. The Agent Harness and Foundry Hosted Agents both reached general availability, which turns a library you build agents with into a platform you run and govern them on. The framework hit 1.0 back in April; Build 2026 in June brought the harness and the orchestration patterns to stable; GA is the part that says you can put it in production and get support when it breaks.

Here is what the harness really is, because the name undersells it. A model on its own generates text. To make it call tools, work through a multi-step job, and keep going until the work is done, you wrap it in a runtime, and that runtime is the harness. Microsoft now ships that runtime so you stop rebuilding it: function invocation, per-call history persistence, context compaction, a plan-and-execute todo list, file memory, skills, web search, tool approval, and OpenTelemetry tracing, each turned on by default and each removable one at a time. The sharper-edged capabilities, shell access, filesystem access, background sub-agents, and automatic looping, stay opt-in and throw a warning when you switch them on. Foundry Hosted Agents is the managed place to run all of it, billed on consumption.

Now the part worth pinning to your wall. In April, a team at MBZUAI’s VILA-Lab pulled apart a Claude Code build whose source was briefly exposed, and classified roughly half a million lines of it. Their estimate: about 98.4% of the codebase is harness, the permissions, context management, sandboxing, tool routing, and recovery, and about 1.6% is the AI decision logic. Grade that number with an asterisk, because the authors do: it is a line count of a partly-generated bundle, not a clean audit. Even cut in half, the direction is the story. Several agents built by different teams landed on the same shape, which points at a property of the problem rather than one company’s taste. The model is the small part. The harness is the system.

You can see why a supported one matters in a single detail from an early benchmark: one runtime halted its own loop after 40 round-trips and reported a limit; another, with host-side stops turned off, ran to 300 without stopping itself. That is the whole argument for buying the harness instead of growing your own. The brake belongs inside the loop, not in a config flag you forgot to set.

Ship it? Yes, and this is the rare lead you can adopt today. It is GA in .NET and Python. If you are hand-maintaining your own agent loop, this is the week to read Microsoft’s and count how much of your code is doing the boring 98% that just became someone else’s supported product.

InfoQ · Microsoft DevBlogs · VILA-Lab paper

Tour de Headlines

⚖️ The EU AI Act deadline hit August 2. The part that bites your agents moved to 2027.

If you only saw the headlines, you would think the hammer came down last week. Here is what the breathless version skipped. On August 2 the Act’s transparency obligations took effect and are now enforceable: disclose when people are dealing with AI, label AI-generated content, the visible-duty stuff. The heavy obligations, the ones on high-risk systems like hiring, credit scoring, and critical infrastructure that everyone spent a year dreading, got pushed from August 2, 2026 to December 2, 2027. That deferral rode in on the Digital Omnibus simplification package, which the Council gave its final green light on June 29 after Parliament signed off on June 16. So if you ship agents into EU hiring or lending: your disclosure duties are live now, your conformity-assessment and CE-marking burden just bought 16 months, and that reprieve is a window, not a cancellation. Embedded high-risk systems get until August 2028. Read it as breathing room to do the boring inventory work right, not permission to skip it.

DLA Piper · Council of the EU

🧮 Kognitos wired deterministic execution into a finance agent.

Kognitos launched Context Graph for Finance, and it is a clean example of fixing reliability in the runtime instead of hoping the model behaves. It encodes the finance world, vendors, invoices, GL accounts, cost centers, approval hierarchies, policies, control thresholds, into one connected graph, then lets specialist agents reason and act on top of it with a symbolic execution layer that runs the same way every single time. It starts with accounts payable. The reason this matters past the CFO’s office: a general model is built to produce the most likely answer, and for approving a payment you do not want likely, you want the approved rule applied identically on every run with every action logged. Determinism is a property you build into the execution path. A prompt can only ask for it. Treat the hallucination-free framing as a launch-day claim on an AP-only release, and take the architecture as the lesson.

GlobeNewswire

💸 OpenAI cut GPT-5.6 Luna by 80%, and the floor under your agent loops dropped.

On July 30 OpenAI dropped Luna’s price 80%: input went from $1 to $0.20 per million tokens, output from $6 to $1.20. Terra came down 20%. OpenAI credits efficiency gains in its models and serving stack. For anyone running agents, this is not a chat-app footnote. An agent loop burns tokens by the thousand per task, so the price of the default workhorse model is the price of running the whole fleet. When the everyday model gets this cheap and the top reasoning tier holds its price, the model quietly becomes the commodity input and the cost and the moat both slide into the harness around it. Re-baseline your per-task math, then spend the savings on the parts a cheaper model does not fix.

VentureBeat · CNBC

Tool of the Day

🐴 Ponytail

What it is for: making your coding agent stop over-building, in about the time it takes to drop in a rules file.

Ask a coding agent for a date picker and it installs a library, writes a wrapper, adds a stylesheet, and opens a discussion about time zones. Ponytail is a ruleset you inject into the agent’s context that makes it behave like the laziest senior dev in the room. Before it writes anything it walks a ladder: does this need to exist, does it already exist in the codebase, does the standard library do it, is there a native platform feature, does an installed dependency already cover it, can it be one line, and only then it writes the minimum that works. It explicitly refuses to cut corners on understanding the problem, input validation at trust boundaries, error handling, security, or accessibility, and it makes the agent mark any deliberate shortcut with the ceiling and the upgrade path. It installs on a dozen agent platforms, Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and Aider among them, and it has pulled past 82,000 GitHub stars since June.

The reason it earns the slot over a hundred other prompt repos is what happened to its scoreboard. Its first benchmark claimed 80 to 94% less code. A contributor dug in and showed the baseline was padded, so the headline was inflated. The author rebuilt the benchmark as a real agentic run on a live repo and published the lower number, about 54% less code on average, in the open. A skill that corrects its own claim when someone checks is rarer, and more useful, than the skill itself.

Get Ponytail on GitHub

Worth a Click

• Vercel Labs shipped a language built for agents to write, not humans. Vercel Labs released Zero, an experimental systems language whose whole premise is that the main reader of compiler output is now an agent. Errors come with stable codes and machine-readable repair plans an agent can accept or reject, and any function that touches the network or filesystem has to declare a capability, so a signature alone tells you what code can reach. Apache 2.0, at v0.3.4, past 5,200 stars, compiles to tiny native binaries. It is experimental and warns you to keep it in an isolated workspace, but it is a real look at what “code written by agents” does to language design. InfoQ
• The agent-governance money keeps flowing: LeapXpert’s $180M. LeapXpert raised a $180M growth round led by Riverwood Capital, with Portage Ventures in, to build AI agents into governed enterprise messaging: WhatsApp, iMessage, Signal, WeChat, SMS, Teams, captured and governed in real time for compliance teams. It is the same thread running under the recent agent-security rounds. The capital is pricing governance as its own category, a thing enterprises buy on purpose. PR Newswire

Delight

😌 Rootly deleted its small-PR rule because the agents write in features.

For two years Rootly ran a strict small-pull-request culture: stacked PRs, atomic changes, a few hundred lines at a time, the discipline every senior engineer preaches. Then they deleted it, and the reason is a tidy little window into what agents really change about the job. The small-PR rule was tuned for human typing speed. Agents removed that constraint, so the rule turned into overhead. Agents do not hand-write a few careful lines; they think in whole features and produce the migration, the model, the service, the controller, the tests, and the frontend in one go. So Rootly stopped using PR size as a proxy for risk and started labeling every PR low, medium, or high, backed by feature flags and rollback, measuring blast radius instead of line count. A backup vendor called Rewind already picked up the same model for its own AI review tool. The quiet lesson: the agents changed how code gets written, and they changed what you watch when you review it.

The model became the cheap part. The runtime is the product.

Line the week up and it points one direction. Microsoft shipped the harness as a supported product and a lab put a number on why that matters: the model is a sliver, the runtime is nearly all of it. Kognitos put determinism into the execution layer because a finance agent needs the rule applied the same way on every run, with the reasoning kept on a leash. OpenAI cut the everyday model 80% and left the top reasoning tier alone, which is the price chart telling you which part is becoming a commodity. And the fastest-growing coding skill of the summer is not a model at all, it is a hundred lines of rules that beat a smarter model at the specific job of not over-building.

So here is the move for anyone running agents past the demo. Stop reaching for a smarter model to fix a reliability problem. Reliability does not live in the model. It lives in the runtime: the brake inside the loop, the deterministic execution path, the identity and the audit trail, the rule that stops the agent from gold-plating a date picker. Buy or borrow that layer now that it is real infrastructure instead of hand-rolling it badly. Reach for a better model when the task genuinely needs a better model, and fix everything else where everything else really breaks. The teams that internalize which half is which will spend the next year shipping while everyone else keeps shopping for a brain.

Ron

You’re receiving this because you subscribed to The Agent Stack.