Open Source Project #245: Raven — The 'Harness of Harnesses' That Orchestrates Claude Code, Codex and More, and Improves Itself Recursively

Introduction

"The Harness of Harnesses."

This is #245 in the "One Open Source Project a Day" series. Today's project is Raven (EverMind-AI/Raven).

Over the past year, coding and general-purpose agents such as Claude Code, Codex, OpenCode, and Hermes Agent have multiplied, each with its own harness (how the loop, tools, memory, and skills fit together). That raises new questions: who schedules all these agents? Who decides which task goes to which? And can the harness itself get better on its own?

Raven's positioning is direct: it's a Host Agent that composes built-in and third-party agents to finish complex tasks, and its modular architecture makes the harness itself something that can be iteratively improved.

What You'll Learn

• Raven's positioning: why 'Harness of Harnesses'
• What the four built-in agents (Research / Code / Design / Oncall) do
• Runtime self-evolution: which four decoupled policy modules the agent loop splits into, and what Curator does
• The five core systems: orchestration, Evolver, EverOS memory, SkillForge, Proactivity
• How to install it and start the WebUI
• Who it suits, and where it falls short

Prerequisites

• Familiarity with the basic LLM agent loop (plan → tool call → observe)
• Experience with coding agents such as Claude Code or Codex
• Some familiarity with agent connection protocols such as MCP / ACP helps

Project Background

Overview

Raven describes itself as "a multi-agent ecosystem for recursive self-improvement (RSI)". It does three things:

1. Hosting and orchestration: as a Host Agent, it coordinates multiple agents, dependencies, and parallelism.
2. Self-improvement: a modular architecture lets it iterate on its own harness — propose a change, evaluate it, adopt what passes verification.
3. Persistent memory: the memory layer is provided by EverOS, so context survives across sessions.

Team

• Team: EverMind-AI (EverMind AI)
• Technical report: Raven: The Harness of Harnesses for Composable Agentic Intelligence, arXiv 2609.33439 (the project page says it ranked first as Hugging Face Paper of the Day, 2026-09-30)
• Ecosystem: EverMind also has EverOS (memory), EverMe (CLI), and research/evaluation projects such as SkillCorpus, EverAlgo, HyperMem, MSA, EverMemBench, and EvoAgentBench, with integrations for OpenClaw, Hermes Agent, DeepSeek Harness, and a Dify plugin
• Community: X, Discord, WeCom
• Creation date: not stated on the project page

Project Stats

• ⭐ GitHub Stars: 5.7k
• 🍴 Forks: 198
• 📝 Commits: 1,910
• 📄 License: Apache-2.0
• 🌐 Website: raven.evermind.ai
• 📚 Docs: evermind-ai.github.io/Raven

Main Features

Core Purpose

Raven targets two problems — how to compose multiple agents, and how to make a harness better. It treats different agents as composable units of capability scheduled by one Host, and splits the key policies of the agent loop so they can be replaced, evaluated, and evolved instead of being hard-wired into a single product.

Use Cases

1. Autonomous deep research

   • Raven-Research produces structured reports with traceable sources.

2. Agentic software development

   • Raven-Code handles feature implementation, debugging, refactoring, and data processing and analysis.

3. Visual design output

   • Raven-Design produces slide decks, brand assets, charts, and web interfaces.

4. Long unattended tasks

   • Raven-Oncall runs experiments, optimization, and continuous monitoring, for hours or overnight.

5. Cross-agent collaboration

   • Plug existing agents such as Claude Code and Codex in as third-party workers, orchestrated by Raven.

Quick Start

The easiest way is to let an agent you already have install it. Give it this sentence:

Read https://evermind-ai.github.io/Raven/quick-start/ and follow it to install Raven, or to update it if it is already installed.

Manual install:

# Linux / macOS / WSL2
curl -fsSL https://raven.evermind.ai/install.sh | bash
 
# Windows PowerShell
irm https://raven.evermind.ai/install.ps1 | iex

Docker (requires Git and Docker Compose):

git clone https://github.com/EverMind-AI/Raven.git
cd Raven
docker compose -f docker/docker-compose.yml up
# then open http://localhost:18793

Start the WebUI:

raven web          # runs in the background and opens a browser
raven web --stop   # stop it

The WebUI supports chat, multi-agent collaboration, workspace management, viewing files and outputs, and browsing memory and skills.

Running the install script directly gives an editable install; piping it installs the published wheel. During setup you choose, for each agent product, whether to use its tuned model (needs a separate key) or Raven's own LLM.

Core Features

1. Four built-in agents

   • Research, Code, Design, and Oncall cover research, development, design, and long-running automation.

2. 13 preset third-party agents

   • Connected through ACP, CLI, or OpenAI-compatible APIs: Claude Code, Codex, OpenCode, Hermes Agent, OpenClaw, MiroThinker, GitHub Copilot, Qwen Code, CodeBuddy, Qoder, Grok Build, Kimi Code, Pi.

3. Evolver: evaluation-driven harness evolution

   • Diagnoses failures, tests candidate improvements, and keeps only changes that beat the baseline.

4. Runtime self-evolution (Curator)

   • Continuously rewrites the four policy modules of the agent loop.

5. EverOS cross-session memory

   • Stores user context, experience, and knowledge.

6. SkillForge

   • Retrieves skills from the local library, EverOS memory, and SkillHub (the project page cites 114,190 skills).

7. Proactivity

   • Event monitoring and scheduled execution for proactive reminders and follow-ups.

8. Persona

   • Describe the assistant you want, and Curator assembles a lead role plus several specialists.

Advantages

The project page gives no formal comparison with similar projects. The table below is my own qualitative comparison based on its positioning, for reference only:

Why it's worth watching

• It turns "the harness is something you can engineer and improve" into a product, rather than leaving it in a paper.
• It doesn't ask you to abandon Claude Code or Codex; it pulls them into the orchestration.
• Improvement has a gate: the project page stresses nothing is installed before verification, failures are reworked, and signals usually have reference answers stripped out.

Deep Dive

Overall structure: Host + Workers + five systems

Raven's core can be summarized as five systems:

Built-in agents

These figures are the project's own claims and I haven't reproduced them. Check the paper and the benchmarks directory before citing them.

The shared harness is improved by Raven Evolver, a standalone tool that uses Raven as a library and evaluates candidate changes against benchmarks.

The four decoupled modules of the agent loop

This is the part of Raven's design most worth a close look. It splits the agent loop into four policy modules:

• Memory: what to remember and how to retrieve it
• Planning: how to decompose tasks
• Capability: which tools and skills exist
• Action: how to execute and judge

Once decoupled, each can be replaced and evaluated on its own. Curator (experimental, shipped in the repo but not in the install package) continuously rewrites these four, swapping tools, skills, procedures, and judgment logic.

This matches what we keep stressing in our evaluation series: for a system to keep improving, its mutable parts need clear boundaries, and trustworthy evaluation must decide which changes stay. Raven's quality rules — nothing is installed before verification, failures are reworked, reference answers are usually stripped from signals — are essentially an evaluation gate on self-improvement.

Showcase cases

The project page gives three:

1. THRESHOLD: a Godot 4 first-person shooter, built autonomously over about 4 days and 42 rounds of plan/develop/verify, also producing posters, a slide deck, and a website.
2. Raven RSI: pretraining optimization on nanochat — 7 rounds, 172 training runs with no crashes, val_bpb reduced 5.8% under the same 20-minute single-GPU budget; dam-break simulation overshoot reduced by three orders of magnitude; an FEA limit-load search finished in 8 bisection rounds.
3. Product launch kit: a web physics mini-game (Angry Raven), a 16-page overview, bilingual posters, and the project README itself.

These are the maintainers' demonstrations. Their value is in showing long, multi-round, verifiable task shapes, not in serving as general proof of performance.

Directory layout

The top level includes agents, benchmarks, evolver, experimental, raven, plugins-dist, skills, ui-tui, ui-web, docker, docs, schemas, rpc-schema, plus files such as AGENTS.md, CLAUDE.md, CONTEXT.md, CONTEXT-MAP.md, CONTRIBUTING.md, CHANGELOG.md, and RELEASING.md. experimental corresponds to the experimental capabilities mentioned above, while benchmarks and evolver are the evaluation side of the self-improvement loop.

Limitations and things to watch

• Curator is experimental and not in the install package, so the full self-evolution capability requires working from source.
• Most performance numbers are self-reported, so verify behavior on your own tasks.
• Cost: long multi-agent runs stack up model calls; overnight Oncall-style tasks in particular need a budget up front.
• Trust boundary: the one-line installer is curl | bash; in production, read the script first or use the Docker route for isolation.
• The project page offers no configuration details or roadmap, so deeper use relies on the official docs.

Links and Resources

Official

• 🌟 GitHub: https://github.com/EverMind-AI/Raven
• 📚 Docs: https://evermind-ai.github.io/Raven/
• 🌐 Website: https://raven.evermind.ai
• 📄 Paper: arXiv 2609.33439
• 🐛 Issue Tracker: https://github.com/EverMind-AI/Raven/issues

Related

• EverMind ecosystem: EverOS, EverMe, SkillCorpus, EvoAgentBench, and more
• Integrations: OpenClaw, Hermes Agent, DeepSeek Harness, Dify plugin

Summary and Outlook

Key Takeaways

1. Clear positioning: Raven is a Host Agent that orchestrates built-in and third-party agents, not yet another monolithic agent.
2. An evolvable harness: the agent loop splits into four decoupled modules — Memory / Planning / Capability / Action — improved by Evolver and Curator under evaluation gates.
3. A complete ecosystem: 13 preset third-party agents, EverOS memory, SkillForge skill retrieval, and Proactivity.
4. Worth reading critically: the self-evolution core (Curator) is still experimental, and performance numbers need your own verification.

Who It's For

• Developers already using several agents such as Claude Code and Codex who want to orchestrate them together
• Researchers and engineers studying harness engineering and agent self-improvement (RSI)
• Teams that need long unattended tasks (experiments, monitoring, batch production)

Suggested Path

Start raven web via Docker or the installer and watch how the Host schedules agents on a small task. Then read the technical report and the evolver and benchmarks directories to see how it uses evaluation to gate self-improvement.

Explore PrimeSkills — a curated marketplace of AI agents and skills, each validated against real enterprise workflows. No hype, just what actually works.

Visit my personal site for more insights and interesting products.