The Short Answer
The agent runtime is now free from two directions, so value moves to what you build on it and where it runs. On ibl.ai you own all the code and the data, run it model-agnostic across any LLM, and pay with no per-seat pricing — so a commoditized runtime is something you adopt into a stack you control, and you can deploy anywhere, including fully air-gapped.
In a single week, the agent loop stopped being something you build or buy.
On August 13, DeepSeek open-sourced Harness under an MIT licence. As of August 24 it stands at 191,498 stars and 21,447 forks — one of the fastest adoption curves GitHub has recorded, and still climbing.
Its organising idea is that everything is a plugin: the model adapter, the tool registry, the session log, the sandbox, and the agent loop itself.
Around the same time, Microsoft's Agent Framework Harness reached general availability — a batteries-included runtime with the tool-calling loop, planning, persistent history, memory, context compaction, approvals, web search and telemetry, in both Python and .NET.
Two very different organisations, converging on the same conclusion: the harness is infrastructure, not product.
What exactly became free?
The scaffolding, which until recently was most of the work.
A third, smaller entrant makes the pattern clearer than either headline does. TrueFoundry's TrueForge — "the runtime layer that turns an LLM into a working agent" — has been public under MIT since July 23, and sits at 2,352 stars.
That is two orders of magnitude below DeepSeek's number, and the gap is the point. This is not one viral repository: three organisations of very different sizes independently concluded that the harness is infrastructure to give away rather than product to sell.
An agent runtime is the loop that lets a model call a tool, read the result, decide the next step, remember what it already did, and keep going until the task is finished.
Around that sit planning, context management, approvals for actions that need a human, and the telemetry to see what happened.
Every team building agents in the last two years built some version of this. It was undifferentiated, it was substantial, and it was frequently the majority of an engagement's engineering effort.
That is what just became a commodity, and the pattern is familiar. Docker made containers ordinary and the interesting problem became orchestration; Kubernetes made orchestration ordinary and the interesting problem moved up again.
The harness layer has now made the same transition, unusually quickly.
Does this mean agent platforms are obsolete?
Only the ones whose differentiation was the loop.
If a vendor's pitch was "we built an agent framework," that pitch expired this month, because two credible free implementations now exist and one of them has 17,000 forks.
What did not become free is everything the loop touches. Permissions-aware retrieval that honours each user's real entitlements across several source systems. An evaluation harness built from your own traffic. Guardrails and prompt-injection defense. Role-based access control.
Audit logging a compliance reviewer accepts. Integrations with your systems of record.
A runtime is a component. A platform is that component plus the layers that make it safe to run against real data, and the second list is where the effort has always actually gone — which is the argument we made in 79% of Enterprises Overran Their AI Budget.
Is the workspace above the agent runtime commoditizing too?
Yes, and from a direction worth noticing: not another framework, but the desktop client people actually sit in front of.
On August 18, Block published Berd under Apache 2.0 — the agent workspace its own teams use internally. Builds ship for macOS, Windows and Linux, it is built on Tauri 2 and React 19, and it reached v0.6.2 in its seventh public release with 91 contributors.
Two design decisions in it are more interesting than the release itself.
It is deliberately multi-harness and multi-model. Berd connects to Block's Goose agent framework over an ACP WebSocket rather than embedding a loop of its own. The model-agnostic argument has arrived one layer up: the client does not want to be married to a runtime either.
It is local-first. Conversation history is stored on-device in the local Goose session database, and credentials sit in the operating system keychain by default. A major fintech shipping its internal agent workspace with that default is a data-residency position, not a UX preference.
Keep the scale honest, though, because it cuts against the headline. Berd is at 732 stars; Goose, the framework beneath it, is at 53,375. This is a company externalising a useful internal tool, not a movement.
What does the fine print say?
Something the enthusiasm is currently outrunning.
DeepSeek Harness is a developer preview, and its own documentation states plainly that there will be compatibility-breaking changes. That is entirely reasonable for a six-day-old project and it is a genuine consideration for anyone thinking about production.
172,741 stars measures interest, not stability. The fork count is the more interesting number, because forks suggest people building on it — but neither tells you whether the API you write against today survives the quarter.
Microsoft's harness is the opposite trade: GA, supported, stable, and tied to the Microsoft ecosystem in ways that matter if you were trying to stay portable.
Berd carries a third variety of fine print. Block accepts no external pull requests — you may fork it and modify it for internal use, but you cannot contribute upstream.
That is a legitimate choice, and it means "open source" here grants you inspection and forking rights, not a seat in the roadmap.
Read every one of these licences and contribution policies yourself. The three projects differ more in what they let you do next year than in what they let you download today.
Neither observation argues against adopting a free runtime. All three argue for keeping the runtime replaceable, which is only possible if you control the layer above it.
Where does the value go when the runtime is free?
To two places, and they are the ones this site has been arguing about for a year.
What you build on it. Your data model, your workflows, your agents, your integrations. This is the part no vendor could have built in advance, and it is the only part that differentiates your organization from a competitor running the same free runtime.
Where it runs. A free runtime does not tell you where inference happens, who can read the data, whether the deployment can operate without external connectivity, or what you hold if a commercial relationship ends.
Those remain architectural decisions, and they are unaffected by the licence on the agent loop.
This is why commoditization is good news rather than a threat to a platform that was never selling the loop. ibl.ai is model-agnostic and runs on your infrastructure with the full source code, so a better free runtime is a component we can adopt — not a competitor that strands us or you.
If the agent runtime is free, what becomes the hard part?
Governance — and specifically, governing what plugs into the runtime.
When building an agent was hard, governance was an afterthought, because the bottleneck was upstream of it. When deploying an agent takes an afternoon, governance is the bottleneck.
An organization running fifty agents across departments has to answer which ones reach which data, who approved them, and what the audit trail looks like.
The plugin architecture that makes these runtimes attractive is exactly what makes this urgent. DeepSeek Harness's organising principle is that everything is a plugin — the model adapter, the tool registry, the sandbox, the loop. Every one of those is a supply-chain entry point.
That is not hypothetical. At Black Hat USA 2026, researchers from Zenity described trojanized AI "skills" uploaded to the skills.sh marketplace, typo-squatting popular services, downloaded more than 1.7 million times in under a month.
A skill is a configuration file that directs how an agent uses tools. Unvetted, it is arbitrary instruction injected into an autonomous system.
So the questions that survive a free runtime are governance questions. Which identity does an agent act under, and can you revoke it?
Does retrieval honour each user's real entitlements, or does the agent see everything the service account sees? Will the logs satisfy a regulator? Where does the data go, and can the deployment run with no outbound connectivity at all?
None of those are answered by a licence on the agent loop. They are answered by the layer above it, which is the layer that was never free — and the one we cover in Agentic AI Governance for the Enterprise and AI Agent Governance: Managing Autonomous Systems.
What should you do about it this quarter?
Four things, in order.
Stop paying for the loop. If a current or proposed contract is priced on an agent framework as the differentiator, that price needs revisiting. Ask what the vendor provides that a free harness plus your own engineers would not.
Do not confuse a runtime with a platform. Adopting Harness or Microsoft's harness does not give you permissions-aware retrieval, evaluation, guardrails, or audit. Those are still yours to build or license, and they are still where the budget goes.
Keep the runtime swappable. The correct response to two free runtimes appearing in one week is not to marry either of them. It is to hold the layer above, so the next one is an upgrade rather than a migration.
Audit your agent footprint before it grows. How many agents are already running across your organization, who deployed them, which plugins and skills did they install, and what data can each one reach? Most organizations cannot answer that today, and the answer only gets harder as the runtime gets cheaper.
The same logic applies one level down at the model layer, which we covered in Model-Agnostic AI: Why Single-Vendor Lock-In Is the Real Risk.
And for institutions currently paying per seat while the runtime beneath them turns free, the arithmetic is in Universities Are Paying Per Seat for a Runtime That Just Became Free.