Raven: The Harness of Harnesses for Composable Agentic Intelligence

Raven. The Harness of Harnesses for Composable Agentic Intelligence. By EverMind AI, from EverMind AI. Published on the twenty-seventh of September. Its code repository is worked out: about three thousand five hundred source files, with a readme and a licence.

As large language models advance, agents are moving away from isolated tasks in a single domain and toward long-horizon workflows that cross domains. That transition exposes two difficulties. Harnesses are growing more complex, which makes designing them by hand hard to scale. And a harness tightly coupled to one domain is limited in how general it can be. The question therefore shifts. It is no longer how to engineer a stronger harness for one domain. It is how to construct specialized harnesses autonomously, improve them through experience, and orchestrate them across domains.

Raven, The Harness of Harnesses, is an open-source multi-agent ecosystem built around that question. It automatically constructs and evolves modular harnesses for specific models and specific domains. The unit it works with is the pair: a model together with its harness, executable as one piece, and treated as a composable unit of intelligence. A model is not considered on its own, and neither is a harness. What gets built, improved, and combined is the working pair.

Those units are combined into what the authors call an All-Domain Collaboration Network. Its Host Agent decomposes a goal, matches the subtasks to specialized agents, coordinates the dependencies between their executions, and integrates the results. Experience is kept rather than thrown away. A host archive and EverOS preserve it from one task to the next, and Skill Forge makes it available again as reusable procedures. The ecosystem therefore does two jobs at once. It splits up and routes the work in front of it, and it accumulates what was learned doing earlier work, so that later tasks can draw on it.

Support comes in two forms. On the theoretical side, the authors establish sufficient conditions under which composition of this kind expands reliable task coverage beyond that of the individual agents available, under a shared resource budget. On the empirical side, Raven significantly outperforms state-of-the-art agent systems on complex and long-horizon tasks.

The bet sits one level above the usual one. Rather than building the best harness, Raven builds the thing that builds harnesses, keeps what they learn, and hands them work. Its theory then says when a team of such pairs can reach tasks that no single one of them could cover alone.

Raven. The Harness of Harnesses for Composable Agentic Intelligence. By EverMind AI, from EverMind AI. Published on the twenty-seventh of September. This is the long version: the whole paper rather than the abstract.

An agent's practical capability depends on two things: its model, and its harness. The paper defines the harness as everything around the model: tool interfaces, context management, skills, execution policies and recovery mechanisms. That dependence creates two problems. Every new tool or execution condition adds design choices that must be configured and validated, so building harnesses by hand does not scale across models and domains. And a specialised harness encodes assumptions about its tools and its outputs, so combining two of them means matching subtasks to the right executor and making the handoffs compatible. Raven's answer is to stop building one harness that does everything, and to compose whole agents instead.

The unit of composition is a model together with its harness, not a role prompt inside one shared framework. Raven joins agents whose harnesses genuinely differ: four native specialists, Raven-Research, Raven-Code, Raven-Design and Raven-Oncall, alongside independently built agents such as Claude Code, Codex and OpenClaw, connected through execution adapters. A registry records each agent's backend and three capabilities: whether it can continue an earlier conversation, whether it can read local files, and whether it streams its progress. The Host Agent reads that registry and plans. There is no separately trained routing classifier. The host's own model makes the choice.

The host works backward from the requested deliverable and submits a directed acyclic graph. Each node names an executor, a prompt template, its dependencies and its input bindings. Before any worker starts, the runtime runs five groups of admission checks: format, graph structure, agent capability, agent status and environment. A file path sent to an agent that cannot read files is rejected, and so is a shared session on a stateless agent. Validation stops at the first failure and returns the error with a pointer to the orchestration guide.

Execution is driven by dependencies: a node runs once every predecessor has completed and been judged. That judgment is the part the abstract does not mention. A returned response does not count as completion. An independent model call reads the rendered prompt, the output and the tail of the transcript, and rules the node accomplished or not, naming a category such as a missing credential or an output limit. A node judged unaccomplished loses its output reference, so no successor can consume it, and the host can continue it with a message, abandon it, or replan while keeping completed work by reference. Every handoff passes through a recorded file rather than a paraphrase. The authors are careful that the judge does not certify correctness: if it times out, a normally returned call counts as accomplished.

Around this sit three adaptation layers. Harness self-evolution keeps the model frozen while an evolver agent diagnoses failure traces and proposes patches, kept only if the patch actually fired and a paired gain clears a fixed cutoff. EverOS memory stores episodes, facts and agent cases. Skill Forge retrieves procedures from local, memory and catalog sources, and lets a model choose at most two.

The planning test is a new benchmark, MAOB: one hundred and forty requests, each paired with a reviewed reference graph over four specialist domains. It scores only the graph the host proposes, before any worker runs. Against Claude Code and Hermes Agent on the same backbone, Raven ranks first on all four metrics with both backbones tested, and Exact Match rises by ten point four and ten point five percentage points. Edge F1, which scores dependencies, stays below Node F1 for every system, so ordering is the harder part.

The specialist results are broad and mostly modest. Raven-Research beats two open research harnesses by three point three to seven point six points across three backbones, and five of the six paired comparisons pass a McNemar test. Raven-Code resolves fifteen more of the seven hundred and thirty-one SWE-bench Pro tasks than Claude Code. Raven-Oncall solves fourteen of seventeen internal science tasks against eleven for Claude Code, at lower reported cost.

There is no dedicated limitations section: the conclusion turns straight to future work. The caveats are scattered, and substantial. The harness-evolution and skill-library results are reproduced from the team's earlier HarnessBank and SkillCorpus papers rather than rerun here. Shared group memory is disabled by default and not evaluated. On the research benchmark, the same questions were used while the research flow was developed, and no system blocked public copies of the benchmarks, so the authors warn that the BrowseComp and Humanity's Last Exam scores may be overestimates. Most comparisons are a single run. The science benchmark is internal and judged by hand, and Claude Code's task statements there included machine addresses and job commands that Raven-Oncall had to choose for itself.

The idea to carry away is a change of unit. Raven does not try to build one better harness. It treats each model with its harness as a callable part, and puts the engineering at the joints: a typed graph checked before dispatch, a judge between every node and its successors, and a file on disk for every handoff. The theory says when that arrangement can beat any single part. The evidence so far shows that the planner draws better graphs, and that each part holds its own. Whether the joined whole beats a strong single agent at equal cost is the experiment the paper itself names, and leaves for later.