HarnessX: Xiaomi's open-source foundry that evolves agent processors on GAIA

Most agent teams still treat the harness as a one-off script: write prompts, wire tools, ship. When the model changes or the task mix shifts, someone rewrites the scaffolding by hand.

HarnessX flips that. Xiaomi's Darwin Agent Team open-sourced a harness foundry where prompts, memory, tools, and control flow are typed processors you swap like Lego. An engine called AEGIS reads execution traces, proposes structural edits, and promotes only what passes regression gates. On GAIA, Qwen 3.5 9B went from 33% to 47% accuracy with no weight updates. The paper is HarnessX: A Composable, Adaptive, and Evolvable Agent Harness Foundry.

If you care about inference cost, this matters more than another leaderboard model. Smaller checkpoints plus an evolved harness can beat naive frontier prompts. That is the economics I track in specialized agentic coding.

Processors, not monolith prompts

HarnessX decomposes the runtime into nine behavior areas:

Each processor is a self-contained module. The foundry applies a substitution algebra: swap, add, or remove processors without rewriting the whole agent.

That matters when you evolve. AEGIS does not mutate one giant system prompt. It searches structural combinations (tool swap, memory policy change, planner tweak) with ordering and uniqueness constraints so the pipeline stays valid.

AEGIS: evolution as RL in symbolic space

AEGIS frames harness adaptation as reinforcement learning over discrete edit actions, not gradient updates on weights.

Digester

Compresses voluminous execution logs into task-level summaries. You cannot feed 50MB of raw traces to a meta-agent every round. Digester keeps the signal: which tool failed, which step looped, which verification missed.

Planner

Chooses the edit landscape for this round: prompt variants, tool parameter changes, new tool implementations, control-flow guards.

Evolver

Programmatically generates candidate harnesses from the plan. Example from the GAIA runs: the task agent kept timing out on JavaScript-heavy Wikipedia pages. AEGIS diagnosed the headless browser failures and wrote a MediaWiki API tool that fetches plain text directly. Swap one processor, unlock previously failing tasks.

Critic and seesaw gate

Filters proposals with an ordering system and a seesaw constraint: a candidate must not regress performance on tasks the harness already solved. Same spirit as Self-Harness held-out gates, applied across processor graphs.

VentureBeat covered the inverse-scaling pattern: weaker models gain more because the harness patches gaps they cannot self-repair.

Benchmark table (why I trust the claims)

HarnessX reports results across five benchmarks and three task-agent families (Claude Sonnet 4.6, GPT-5.4, Qwen3.5-9B):

Average +14.5% absolute across 15 model-benchmark pairs, improving in 14 of 15 configs. Gains shrink when baselines already saturate (τ³-Bench), which is what you want from an honest eval.

Model-harness co-evolution

HarnessX also closes the loop to training. After harness evolution lifts the baseline, Cross-Harness GRPO can fine-tune the model on trajectories collected across harness versions. On Qwen 3.5 9B, combined evolution reportedly moved GAIA from ~34% to ~56% (+64% relative). Harness first, weights second.

Run it yourself (GAIA evolver recipe)

The repo is MIT licensed: Darwin-Agent/HarnessX.

High-level steps from recipe/gaia_evolver/:

git clone https://github.com/Darwin-Agent/HarnessX
cd HarnessX
# follow benchmarks/README.md for dataset adapters
# configure meta-agent (trace analysis) and task-agent model endpoints
# run evolution rounds with budget cap (e.g. 15 rounds)

Conceptual API shape from community ports:

from engine.aegis_engine import AEGISEngine
from engine.meta_agent import MetaAgent

engine = AEGISEngine(
    meta_agent=MetaAgent,
    initial_harness=harness,
    budget=15,
)
evolved_harness = await engine.evolve(task_ids=["task_1", "task_2"])

Set a budget on evolution rounds. Unguided search is loopmaxxing with extra steps. The paper's stable gains came from critic gates and variant isolation on heterogeneous task sets (GAIA stagnates with a single shared harness; isolated variants recovered +13.6% over 15 rounds).

HarnessX vs Self-Harness vs hand-tuned stacks

Framework	Open source	Unit of edit	Standout result
Hand-tuned harness	N/A	Human intuition	Fast for one model, brittle on swap
Self-Harness	Research only (mid-2026)	Minimal prompt/code diffs	+33% to +60% on Terminal-Bench
HarnessX	Yes (GitHub)	Processor graph + tools	+14.5% avg across 5 benchmarks

Both Self-Harness and HarnessX share the same production lesson I wrote about in loop engineering: traces in, gated edits out. HarnessX goes further on composability and ships runnable code.

What I would watch in a pilot

1. Meta-agent cost. Evolution uses a strong model (Claude Opus 4.6 in the paper) to write harness changes. Budget that separately from task-agent inference.
2. Task homogeneity. Single-harness evolution stalls on mixed GAIA tasks. Plan variant isolation if your production queue is diverse.
3. Tool safety. Auto-generated tools (MediaWiki fetchers, shell wrappers) need the same sandbox review you would give a junior engineer's PR.

Practical takeaway

You do not need a 200B model to ship reliable agents. You need a harness that learns from its own failures under strict gates. HarnessX is the first open foundry I would point a team at when they already have traces and a benchmark slice, but prompt edits stopped moving the needle.

For a lighter-weight pattern without the full foundry, start with the manual regression loop in Self-Harness. For full processor search, clone HarnessX and cap AEGIS rounds.

Building agent infra for a product team? Book a free call. I help teams pick where evolution belongs (harness vs model vs workflow) before they burn a month on the wrong loop.