Skip to content
←Back to the radar

SOTA · agents

Agent Harness

Agent runtimes: plugins and sandboxes, tool surfaces, skill systems, long-term memory and self-improvement.

Model capability sets the ceiling; the agent runtime decides how much of that ceiling you actually get. Swapping the scaffold under the same model can more than halve or double long-task completion, and this is not rhetoric: a Terminal-Bench score is only meaningful if you record the harness version next to it, because the number is the product of model times runtime, not a property of the model alone. So this domain measures the layer beneath the agent - how plugins and tools are mounted, where the sandbox and permission boundaries sit, whether the skill system lets the agent write its own tools and reuse them afterwards, whether long-term memory and session resumption work, and whether a self-improvement loop is real (does the experience summarised after a task actually get used in the next one). The connection to AGI is that model weights are frozen once shipped, while the runtime is the layer that can keep getting stronger after deployment. The open-source projects at the top of today's ladder all take the same route: memory, skills, sandboxing and persistence are explicit runtime capabilities rather than another paragraph appended to an already long system prompt. To judge whether a harness is worth running, ignore how many demos it completes and check three things: can it resume from the exact point where it crashed, is there a hard boundary on privileged operations, and do skills and memory accumulate across sessions.

RULERLong-task completion, plugin & skill ecosystem, sandbox & telemetry, cost & latency per task

The ladder

8
Agent Harness

DeepSeek Harness: the open-source agent runtime where everything is a plugin

DeepSeek AI's open-source agent harness (CLI dsh, MIT, 233k+ stars). The kernel provides only plugin-system semantics; tools, surfaces and model access all attach as plugins, on top of Cordis' paradigm for spatiotemporal composability (arXiv:2608.25512). It is in developer preview with an explicit warning about compatibility-breaking changes, and SAFETY.md is required reading before you run it. Not benchmarked yet, so this entry is graded as needing reproduction.

234kGitHub stars
DeepSeek Harness: the open-source agent runtime where everything is a plugin
Agent Harness

Pi: a layered agent harness monorepo

Pi Agent Harness (formerly badlogic/pi-mono; 108k+ stars, MIT/TypeScript). Not one CLI but layered packages usable on their own: pi-coding-agent (interactive coding agent), pi-agent-core (runtime with tool calling and state), pi-ai (unified multi-provider LLM API), plus chord composition runtime, pi-telemetry contracts, pi-durable persistence and pi-tui differential terminal rendering. The README states plainly that there is no built-in permission system and offers micro-VM / Docker / sandbox paths instead. Not independently benchmarked; graded needs-reproduction.

109kGitHub stars
Pi: a layered agent harness monorepo
Agent Harness

Impeccable: the design language that makes your AI coding agent better at design

An open-source design skill by Paul Bakaus: 1 skill, 24 commands and 61 deterministic anti-pattern detector rules that kill AI frontend slop (Inter everywhere, purple gradients, cards-in-cards). Installs into 16 harnesses including Claude Code, Cursor, Codex and Gemini CLI; live browser iteration plus a Chrome extension. Pure Markdown rules with a zero-LLM detector engine. Apache-2.0, 75k+ stars.

76kGitHub stars
Impeccable: the design language that makes your AI coding agent better at design
Agent Harness

Diagram Design: an editorial diagram skill for coding agents

An MIT-licensed agent skill that turns Claude Code, Codex, Factory Droid or Pi into a diagram design tool: 44 visual types, 211 self-contained HTML examples, semantic patterns orthogonal to layout, a first-run gate that forces brand-token verification, and a render lint that catches clipped SVG by pixel diff.

47kGitHub stars
Diagram Design: an editorial diagram skill for coding agents
Agent Harness

Deep Agents: an off-the-shelf agent harness reverse-engineered from Claude Code

The README opens by calling itself an off-the-shelf agent harness: MIT licensed, Python (plus deepagents.js), built on LangGraph, so streaming, durability and checkpoints are inherited rather than rewritten. The key to reading it is the acknowledgement - inspired by Claude Code, trying to figure out what makes it general and pushing that further - which makes this a reverse-engineering exercise: take a closed coding agent that is known to work well, open it up, and ask what actually lets it handle long tasks. Its answer is four bundled things: a pluggable-backend file system (the artefacts of long tasks are files, not messages, so context keeps only pointers), sub-agents each with their own window (context isolation and compression, not extra helpers), long-thread summarisation with tool output offloaded to disk, and on-demand Skills. Also sandboxed shell execution, cross-session persistent memory, human-in-the-loop approval/edit/reject before a tool call runs, and any MCP server as a tool. Model agnostic: frontier APIs, open weights hosted on Baseten or Fireworks, and self-hosted Ollama/vLLM/llama.cpp all work, with three lines of create_deep_agent giving you a planning, file-reading-and-writing agent. The security section is unusually blunt - it follows a trust-the-LLM model, boundaries must be enforced at the tool and sandbox layer, and you should not expect the model to restrain itself. 29.7k stars. Not run yet; sub-agent isolation quality and summarisation information loss are unverified, so this is graded as pending reproduction.

30kGitHub stars
Deep Agents: an off-the-shelf agent harness reverse-engineered from Claude Code
Agent Harness

Learn Harness Engineering: a project-based course on making AI coding agents reliable

An open-source, project-based course (14 lectures, 8 projects, 15 languages) on building the instructions/state/verification/scope/lifecycle subsystems that make frontier models reliable inside real repos — includes reverse-engineered harness breakdowns of Pi, Claude Code, Codex and DeepSeek, plus loop- and graph-engineering advanced lectures. MIT licensed, ships a harness-creator skill and a zero-dependency audit script.

19kGitHub stars
Learn Harness Engineering: a project-based course on making AI coding agents reliable
Agent Harness

claude-quickstarts: the Claude app reference code Anthropic uses itself, opened up - 18 runnable projects across sessions, tools, computer use, and Managed Agents

Anthropic opened up the reference code it uses to build Claude apps as claude-quickstarts: 18 fully runnable projects in three tiers - chat apps (customer support, financial analysis), desktop and browser operation (computer-use demo, a native-macOS best-practices reference, minimal browser and computer toolset examples), and long-running agents plus the Managed Agents ecosystem (multi-channel chat, AG-UI generative UI, cron deployments, a distilled knowledge wiki, a nine-tool MCP server). MIT licensed, about 18.6k stars at capture. The closest read is computer-use-best-practices: screenshot resizing, prompt caching, server-side compaction, batched tool calls, a sandboxed shell, and trajectory recording, all written directly into code.

19kGitHub stars
claude-quickstarts: the Claude app reference code Anthropic uses itself, opened up - 18 runnable projects across sessions, tools, computer use, and Managed Agents
Agent Harness

Midscene.js: A Vision GUI Agent and E2E Testing Framework

ByteDance Web Infra open-source vision GUI agent and E2E testing framework. It locates elements from screenshots instead of selectors and drives Web, Android, iOS, HarmonyOS and desktop through one API, shipping YAML cases, TypeScript nodes, replayable reports and CLI skills for coding agents. An agent-harness layer, not an AI-coding tool.

15kGitHub stars
Midscene.js: A Vision GUI Agent and E2E Testing Framework

Latest demos

30

Papers & deep reads

35
DiscoveryRSI: Recursively Learning to Discover Valuable Hypotheses2026-10-16DiscoveryRSI: Recursively Learning to Discover Valuable HypothesesScientific discovery requires developing worthwhile hypotheses into practical investigations, yet learning from this evolving research process remains challenging. We introduce an operational definition of valuable and testable research hypotheses: evidence-grounded claims about consequential uncertainties, coupled with feasible investigations, explicit decision criteria, and alternative explanations. Our DiscoveryRSI framework develops hypothesis trees through multi-agent evolutionary search, compiles selected investigations into executable Harbor tasks, and recursively learns through three mechanisms: hypothesis credit optimization attributes scientific assessments to documented research contributions; harness replay identifies productive strategies and recurring failures to refine research workflows; and rediscovery applies accepted improvements to new investigations, generating further experience for subsequent learning. We also introduce DFM-Bench, which provides comprehensive assessment of hypothesis quality and cumulative research progress at the levels of hypotheses, revisions, development paths and research runs. Across four life-science domains, automated evaluation shows that hypothesis quality rises from 4.86 for the base model to 5.39 after two rounds of self-improvement, with the large gains in falsifiability and data resolvability. We further validate hypothesis quality through expert review, comparing our DiscoveryRSI-27B with other research agents. Preliminary human assessments show that DiscoveryRSI-27B scores higher than GPT-6 Luna on hypothesis importance and whether claims are plausible and evidence-bounded. DiscoveryRSI-27B achieved a 6.3% rate of hypothesis correspondence with research published after the model cutoff, largely outperform GPT-6 with 2.5% and Claude Opus 5 with 2.3%, while delivering greater human-rated improvement along research paths.
The Agentic Scientist: Orchestrating Coding Agents for Automated Scientific (Co-)Discovery2026-10-13The Agentic Scientist: Orchestrating Coding Agents for Automated Scientific (Co-)DiscoveryModern coding agents are fundamentally reshaping the role of human input for computational research: they write code, launch in silico experiments, analyze their results, and autonomously operate with ever-increasing time horizons. Despite these developments, fully autonomous research agents suffer from a limited ideation radius and myopic hill-climbing search dynamics. To bridge this gap, we introduce The Agentic Scientist, an end-to-end distributed pipeline for human researchers to conduct computational research alongside modern coding agents. Building on its predecessor, our system decomposes research into task drafting, idea generation, planning, sandboxed experimentation, result aggregation, baseline and ablation construction, post-hoc analysis, and report writing. Importantly, each step in the pipeline is powered by the next generation of coding agents and leverages agentic self-verification. The overall research process is driven by a meta-controller that manages parallel research agents and enforces rubric verification at each stage. This design enables the same orchestration layer to be reused across heterogeneous domains with different execution environments, agentic coding harnesses, and evaluation metrics. Our system can be used across a spectrum of autonomy: either as a co-scientist tool or to perform end-to-end scientific investigation. Within the co-scientist setting, we leveraged a development version of our system to submit a single research paper, which got accepted for publication at ALIFE 2026. We further apply The Agentic Scientist fully autonomously to open problem-solving tasks in machine learning, and demonstrate the system's capability of scientific discovery across different domains of computational research. Our ablations suggest that reliable scientific autonomy depends not only on base model capabilities, but also on the cross-agent orchestration layer.
Recursive Game Creator: An Agentic Product-Level Experience-Oriented Game Harness2026-10-06Recursive Game Creator: An Agentic Product-Level Experience-Oriented Game HarnessRecent game design agents have made substantial progress in generating playable games. However, program correctness does not ensure an enjoyable experience for players. We present Recursive Game Creator, an experience-oriented harness to advance agentic game development from rough game prototypes into entertaining games. Recursive Game Creator organizes recursive development around four components: Designer, Builder, Player, and Reviewer. The Designer translates user instructions and Reviewer's feedback into detailed plans. The Builder turns these plans into candidate games. The coding-native Player creates and executes reusable policies through programmatic interfaces to efficiently collect diverse gameplay trajectories, mitigating evaluation bias caused by slow GUI-based collection. The Reviewer uses carefully designed trajectory-based metrics to induce player preferences, integrating with visual evidence and explicit textual preferences to evaluate games against game-specific criteria. Finally, the Reviewer accepts the better version and provides improvement reviews for the next round, closing the recursive loop. Our method achieves state-of-the-art overall performance of 77.89 on GameCraft-Bench. On GameASG-Bench, it achieves a strict task success rate of 53.2%, a 34.1% improvement over the same-model baseline, and the highest mean runtime-check pass rate at 93.4% among compared methods. A user study shows longer playtime and higher ratings. Code is coming soon.
The ultimate guide to multi-harness RL: train models inside Claude Code and Codex — Hugging Face's four-harness experiment with a 2.6B model2026-10-01The ultimate guide to multi-harness RL: train models inside Claude Code and Codex — Hugging Face's four-harness experiment with a 2.6B modelThe same model behaves like two different models depending on the agent harness around it: GLM-5.2 scores 23% in one harness and 52% in another on SWE-bench Pro; in a controlled experiment swapping the harness moved scores 13 points while swapping the model moved only 2.5–5. A Hugging Face team (Adithya S Kolavi, Joel Niklaus, Lewis Tunstall, Leandro von Werra and colleagues, with Liquid AI) publishes an open fix: run agentic RL inside the real harnesses — Claude Code, Codex, OpenCode, Mini-SWE-Agent — with zero harness code changes. The stack: OpenEnv as the shared interface, a capture proxy that mints a session id per rollout and records exact token ids, per-token behavior logprobs and loss masks at the model endpoint (full-distribution sampling, top_p=1.0), Harbor for 40+ harness adapters and 26 sandbox backends, and TRL's Async GRPO consuming the masked training sequences. The numbers: LFM2.5-2.6B trained across four harnesses rises from 42.2% to 54.2% average pass@1 with gains under all four, and uses 31% fewer tool calls on tasks both it and the base model solved, while the OpenCode-only arm's gains stay mostly at home. The article also reports the SFT comparison (RL 54.6% vs SFT 47.5%), the full attribution of the earlier Qwen rise-and-decline (output-budget exhaustion, working without submitting, and a reward term that collapsed held-out accuracy from 0.740 to 0.178), and engineering boundaries like the proxy's concurrency ceiling.
World Action Agent: Harnessing VLMs for Robot Manipulation via World Action Rehearsal2026-09-24World Action Agent: Harnessing VLMs for Robot Manipulation via World Action RehearsalHKUST(GZ), CUHK and Knowin AI present World Action Agent (WAA), a multi-agent harness that changes what the VLM sees and how its decisions take effect — rather than the VLM itself — so a general-purpose VLM can pilot a robot with basic tools (point, drag, preview, execute), making every decision inside one visual action workspace. Three properties: Contact views, whose camera parameters are solved from interaction-region visibility under occlusion, framing compactness, view redundancy and stability, with the feasible set constraining the two views to orthogonal horizontal projections so any alignment error can be read along two independent directions — requiring only a base-frame point cloud, so the perception source (simulation, fused RGB-D, or VGGT reconstruction) is irrelevant; action rehearsal, where each action is an editable proposal planned by cuRobo, overlaid as a translucent robot in every view with a feasibility report, refined by an Imagination Agent in a separate context while the physical scene stays unchanged, and only proposals with executable plans become motion; and in-view correction, where the agent drags from a reference point to the desired location in the Contact view where the error is observed — the reference can be a visible point on the held object, so no conversion into an absolute gripper pose is needed. Skills evolve from expert videos and human Canvas-GUI teaching through Learner, Editor and Reviewer roles under evidence-citing and independent-review constraints. On LIBERO-Pro with Gemini 3.7 Flash, using skills evolved only from LIBERO-90 and frozen before evaluation, WAA reaches a state-of-the-art 75.6% average success, above ASPIRE (72.0%), end-to-end VLAs and the same-backbone Show-Harness (6.7%), scoring 80.0 / 73.3 on the two Spatial splits; an episode costs just 31 model calls, 150 s and $0.1996 versus 120 calls, 874 s and $0.5021 for Show-Harness. The frozen skills transfer to robosuite at 100.0%, and LoRA fine-tuning Qwen3.5-9B on 112 trajectories (1,774 decision steps) as the main agent only raises out-of-domain success from 1.7% to 43.3%.

Open source

31

Assets you can use now

No installable skill wired to this domain yet.

Boundaries & failure modes

The boundaries here are harder than on the model side, and most of them are engineering and trust problems rather than algorithmic ones. No common ruler: this domain has almost no accepted leaderboard. Terminal-Bench, OSWorld and GAIA measure a model paired with one specific scaffold, and the score moves when the harness changes, so ranking two runtimes against each other is basically not possible - which is why this domain records checkable engineering facts here (persistence, sandbox boundaries, size of the skill ecosystem) instead of completion-rate tables. Self-improvement is unproven: projects such as hermes-agent sell the idea that the agent writes its own skills after a task and then refines them in use. The claim is strong, and falsifiable controlled experiments (same model, same tasks, loop on versus loop off) are almost absent from public data, so all of it is marked needs-reproduction. Permissions and safety are the weak spot: most open-source runtimes either have no permission system at all (pi's README says so itself) or only a confirmation prompt. An agent that can run a shell, edit files and reach the network crosses a line after one prompt injection, so sandboxing is a requirement, not an option. Stars do not equal usability: community heat at this layer tracks release cadence closely, and a project with tens of thousands of stars may still only support one model family on one operating system - you pay the evaluation cost yourself. Cost and latency are systematically underestimated: the runtime decides how many model calls a task needs and how much context each call carries. The same task can differ by several times in token bill between "one long context" and "many small steps plus retrieved memory", and tool-call retries inside long tasks amplify that again, so budget for the worst case.

As an Amazon Associate, we earn from qualifying purchases.