Agnes AI Open-Sources Agnes Harness: The Agent Execution Layer Is Becoming the New Battleground

This Time It's Not a Model — It's Where the Model Works

On October 10–11, Chinese tech media AI Era (新智元) reported a move worth the vibe coding community's attention: Agnes AI open-sourced Agnes Harness (AGH), positioned as "agent execution infrastructure for real-world tasks." Open-sourced alongside it were the MHS device interaction protocol, the MOS 1.0 perception data protocol, the AgnesHub device connectivity component, plus Python/TypeScript SDKs and an mhs-check conformance test suite. Agnes also published benchmark scores for its new Agnes 3.0 Pro model: 91.11 on GPQA, 56.13 on the scientific-coding benchmark SciCode — just 0.97 points behind GPT-5.6 Sol (Max) at 57.1 — and 48.0 on the Tau3-Banking simulated banking evaluation, first among the compared models.

Let's set the numbers aside for a moment. This piece isn't about "yet another Chinese model climbing the leaderboard." It's about AGH itself: for the past two years, agent competition has happened almost entirely at the model layer — who has the longer context, the more accurate tool calls, the higher benchmark scores. But what actually torments those of us who ship with agents isn't model capability. It's the layer beneath the model: the agent that dies halfway through a task, drifts off track, gets stuck retrying the same tool, and finally shrugs, "I did my best." AGH is betting on exactly that layer.

What AGH Is: The Runtime Underneath the Agent

Per the official description, AGH is agent execution infrastructure for real-world tasks, handling four things: continuous execution, tool invocation, state management, and result feedback. Developers get two interfaces: a Web workbench — a local chat UI where you point the agent at a working directory and let it read files, run commands, and modify your project — or a CLI. The core agent loop works like this: the model decides what to do next, the harness actually invokes the tools and feeds results back, until the task completes or a human steps in.

The division of labor sounds unremarkable, but it separates two things that have always been tangled: the model does the thinking, the harness does the doing. Our biggest discomfort with coding agents over the last two years comes precisely from this layer never being split — the model thinks and acts at the same time, and when it fails you can't even tell whether it "thought wrong" or its hand slipped. AGH's architectural choice at least acknowledges, conceptually, that execution is its own craft, deserving its own infrastructure.

The Trajectory View: Finally Opening the Black Box

The design choice I like most in AGH is its "trajectory" page. After a task runs, you can replay the whole execution along a timeline: which tool the model called at each step, how long each step took, and drill into tool parameters and execution status. The pitch is that it helps you answer one question: "was this a model judgment failure or a tool execution failure?"

That question deserves unpacking. Anyone who has run an agent on a nontrivial task knows the despair: a 40-step task dies at step 31, you scroll logs until your eyes glaze over, and still can't say whether the prompt was unclear, the model hallucinated a parameter, or the target API was just having a bad day. So your debugging degrades into "rephrase and rerun" — that's not engineering, that's superstition. Trajectory replay turns execution into an observable, reviewable data structure, which means agent debugging gets something like a "breakpoint" for the first time. That matters especially for solo builders: you don't have an SRE team watching your agents, so the execution layer has to bring its own observability.

Zoom out, and this is a mandatory step in the maturing of agent engineering. Traditional software has logs, traces, profilers; agents are only now starting to catch up. AGH making trajectories a first-class citizen is the right direction — whether the replay granularity is fine enough and the overhead low enough will only be known once the community actually uses it.

Plugins, MCP, Skills: Well-Chosen Territory

AGH's extension story has three layers: a plugin system for wiring in your own business tools; MCP for connecting existing services; and validated task methods that can be distilled into Skills and reused across projects. There's also an App Server so the web UI and CLI share the same backend session.

Skills is the most interesting piece. The idea: when you've tuned a reliable way of completing a class of tasks in one project, don't let it rot in your chat history — distill it into a Skill and reuse it in the next project. That's the same idea as our earlier guide on "prompts → Skill sedimentation" — except that guide spoke from the personal-workflow angle, while AGH builds it into the infrastructure layer. Once "sedimentation" graduates from personal habit to platform capability, Skills start to become circulable: today you reuse your own, tomorrow you might install someone else's. If that road goes through, agent capability growth will no longer depend solely on model vendors shipping new versions, but on the whole community adding bricks to the execution layer.

The MCP integration is a pragmatic call. Don't reinvent the wheel — just be compatible with the MCP ecosystem that's already running. AGH clearly understands its job is the "execution layer," not the "connection layer." Good boundary discipline.

The MHS Protocol: Agents Step Out of the Screen

If AGH is about "making agents work reliably in the software world," the simultaneously open-sourced MHS (Model Hardware Standard) is about "letting agents touch the physical world." MHS is a device interaction protocol that, together with the MOS 1.0 perception data protocol, the AgnesHub connectivity component, and the mhs-check conformance suite, lets an agent connect to software tools and programmable hardware within the same execution environment.

The official demos: a mobile cart in an office finds a specified book and reads it aloud; and in the virtual Mars base "Mars World" — for which the official repo provides 11 virtual devices — a multi-device rescue simulation where the agent dispatches aircraft to search, robots to rescue, and coordinates the base airlock. Demos are demos, but the direction is clear: an agent's "tool calls" shouldn't stop at APIs and CLIs — physical devices should be schedulable as just another kind of "tool."

The idea is more radical than it looks. Embodied intelligence and software agents have historically been two crowds with two stacks: the robotics folks talk ROS and real-time, the agent folks talk function calling and context. MHS tries to pull both crowds to the same table with one protocol. If it works, then in your future agent apps, "send the cart to the third floor for a parcel" and "call a weather API" might be the same kind of operation at the code level. That's good news for indie developers — once the hardware integration barrier drops, vibe coding subject matter expands from "yet another productivity tool" to "things that touch the real world."

Of course, open-sourcing a protocol is only step one. Hardware ecosystems are notoriously hard to cold-start: without enough device vendors implementing MHS, the protocol is just a document. AgnesHub and the mhs-check conformance tests are laying groundwork for that, but it's a long road.

The Model Scores: Agnes 3.0 Pro Hands In Its Paper, Flash Stays Free

Back to the model itself. Agnes 3.0 Pro's reported scores: 91.11 on GPQA; 56.13 on SciCode — a scientific-coding benchmark where it trails GPT-5.6 Sol (Max)'s 57.1 by less than a point; 48.0 on Tau3-Banking, first among the compared models. The API is coming soon, and 3.0 Flash remains free.

Honestly, on numbers alone Agnes 3.0 Pro has entered the first-tier conversation, especially on SciCode, which tracks real scientific programming. But longtime readers know our standing attitude toward vendor-reported scores: the comparison set is self-selected, the test conditions self-defined. Treat the numbers as directional; what matters is how the community benchmarks it once the API is live. One thing is certain, though: by packaging model scores with execution infrastructure in a single announcement, Agnes is signaling it doesn't want to be just a "model vendor" — it wants to define how agents get work done.

Our Take: The Battlefield Is Sinking From "Models" to the "Execution Layer"

Placed on the 2026 timeline, the trend is unmistakable. The first half of the year was about models: parameters, context windows, benchmarks. The second half's moves increasingly land at the execution layer: continuous running, state management, trajectory observability, skill sedimentation, hardware connectivity. Models are commoditizing; differentiation is migrating downward.

That sentence has three direct implications for vibe coding readers. First, when choosing agent tooling, don't just look at which model sits underneath — look at the execution layer: resumable runs, failure retries, execution replay. Those are what decide whether you're woken at 3 a.m. by a dead agent. Second, distill your tuned workflows into Skills instead of letting them rot in chat history — AGH making Skills a first-class citizen shows "sedimentation" is becoming industry consensus; the earlier you start, the more you benefit. Third, keep an eye on hardware protocols like MHS. The day agents can touch the physical world, the subject-matter boundary of the "one-person company" opens up considerably.

A final note of sobriety. The AGH GitHub repo (AgnesAI-Labs/agnes-harness, Apache 2.0) is currently in developer preview, created on September 22, with star counts still in the double digits. In other words, this is an early project with the right direction and an honest "not ready yet" label — not a production tool you should switch to today. We're writing about it not to recommend a migration, but because the direction it points to — the execution layer, observability, skill sedimentation, software-hardware unity — is very likely where agent infrastructure keywords will live for the next year or two. Understand the direction first, then decide when to board.

Why Now, Why Open Source: Three Pieces of Context

First, FDE — Forward Deployed Engineering — has been red-hot in China's hiring market this year. The core idea: no matter how capable the model, someone has to deploy the agent into the client's actual business process for the last mile — wiring internal systems, handling exceptions, keeping long-running tasks stable. Execution infrastructure like AGH is exactly the missing brick FDE engineers need most. Previously everyone built that wheel themselves; now someone has open-sourced it, which moves the starting line for delivering agent projects forward for everyone. For indie developers, it means the next time you take on "build an agent workflow for a small company," you start from a ready-made foundation instead of hand-rolling retry logic and state machines.

Second, the license choice: Apache 2.0, the most permissive tier — commercial use, modification, closed-source redistribution all allowed. That contrasts with some Chinese model vendors' "API-only, weights withheld" approach. Agnes's calculus isn't hard to read: at the model layer it faces GPT and Claude head-on, where the outcome is uncertain; but at the execution layer there's no acknowledged winner yet, so it uses Apache 2.0 to claim the territory first, betting that whoever defines the de facto standard of the execution layer owns the discourse power of agent applications. The logic rhymes with how Kubernetes won container orchestration — the winner wasn't the most technically brilliant, it was the one whose ecosystem got going first.

Third, the timing is sharp. Early October is exactly when every agent tool is patching "long-task reliability": Claude Code added checkpoints, Codex added background tasks, Cursor added remote execution. Everyone has realized the next bottleneck for agents isn't "can it write code" but "can it run a three-hour task from start to finish." AGH open-sourcing "continuous execution + trajectory replay + Skill sedimentation" as a package in this window effectively commoditizes and open-sources capabilities the big players are still beta-testing internally. That's pressure for the giants and a dividend for us — the more infrastructure vendors compete, the more leverage indie developers get.

One clarification, so it doesn't get confused with earlier coverage: the previously mentioned openJiuwen AgentOS is about "orchestrating many agents in the enterprise"; AGH is about "one agent executing continuously and reliably, plus hardware connectivity." One manages how a crowd of agents collaborates; the other manages how a single agent gets the job done right. Different layers entirely.