Coming next: The Harness of Harnesses is Raven's next-version direction, not a capability of the current public release.
The current public release of Raven is the open-source, self-improving Agent Harness you can run today. It brings terminal-first execution, local tracing, long-term memory, skills, evaluation, and reusable workflows into one system for long-running AI work.
As AI agents move from narrow tasks toward long-running, cross-domain work, manually designing a single, ever-larger harness stops scaling. A harness optimized for one model or domain also cannot provide every capability needed for general intelligence.
Raven's next version will move toward The Harness of Harnesses: a continuously evolving multi-agent ecosystem built for autonomous collaboration and open co-creation. It is designed to build and improve Agent Harnesses for specific models and domains, then compose their heterogeneous execution capabilities into an All-Domain Collaboration Network.
| Trusted | Persistent | Evolving |
|---|---|---|
| Harness capabilities will be scored based on verified performance, not self-declared labels. | The network is designed to carry verified results, task state, and long-term memory across executors. | Each verified run will feed experience back into capability profiles, skills, routing, and the wider network. |
This next-version architecture is designed to move beyond fixed model-harness pairs. Through a continuous evaluation -> execution -> verification -> memory -> feedback loop, it will discover, compose, and improve the right capabilities for each task. Validated work will become reusable experience, allowing both individual agents and the wider capability network to evolve.
The internal research prototype behind this direction has been evaluated across 22 Agent benchmark tasks covering task performance, cost, and key mechanism gains. The reported results show comprehensive performance and efficiency improvements over existing agent systems while advancing the quality-cost Pareto frontier.
The current public Raven release does not yet implement The Harness of Harnesses. Raven today is the runnable self-improving Agent Harness described in this repository; the section above describes the next version we are building toward.
Raven is pre-alpha. Interfaces and configuration may change quickly.
| Benchmark | Research Prototype Result | Comparison |
|---|---|---|
| Efficiency | 56.7% at 27B; 58.1% at 397B |
Hermes 46.8% / 47.9%; +9.9pp at 27B |
| Self-evolution | Ranked #1 on EvoAgentBench |
+6.2pp over the next result across four methods |
| Proactivity | 0.60 F1 on ProAgentBench |
2.4x Hermes/OpenClaw at 0.253 |
These results come from the internal research prototype. They do not mean that the current public release already supports the Harness of Harnesses network. Model, task set, and evaluation protocol all affect outcomes.
otty-raven-onboarding.mp4
Linux, macOS, or WSL2:
curl -fsSL https://raven.evermind.ai/install.sh | bashNative Windows PowerShell:
irm https://raven.evermind.ai/install.ps1 | iexWindows PowerShell 5.1 may reject the redirect. Use the direct installer URL instead:
irm https://raw.githubusercontent.com/EverMind-AI/Raven/refs/heads/main/install.ps1 | iexravenThat is the whole first run: with nothing configured yet, raven walks you through setup and then opens the TUI in the same session. To reconfigure later, run raven onboard explicitly.
The bilingual onboarding wizard configures six areas without requiring manual edits to ~/.raven/config.json:
- LLM provider and model
- Sandbox or execution location
- Chat channels
- EverOS long-term memory
- Deep Research
- Cold-start import from other AI tools
Provider setup includes an in-step connectivity check. Optional steps can be skipped and configured later. If setup is incomplete, run:
raven doctorraven upgrade --check
raven upgradeUpgrades preserve configuration, sessions, and memory. Raven does not update automatically.
Deep Research gives Raven a dedicated path for open-ended questions that require broad web search, source reading, analysis, and multi-source cross-checking. It uses MiroThinker and returns a self-contained answer with inline citations and references.
Configure it during onboarding or later:
raven deep-research enable
raven deep-research getOnce configured, Raven can invoke deep_research when a task needs more than a quick lookup. Before a paid, minute-scale run, interactive surfaces ask whether to use Deep Research or regular search for that query.
Delivery adapts to where Raven is running:
- CLI and TUI: progress streams inline while Raven searches, reads pages, and runs analysis. The completed report is shown directly without being rewritten by the main model.
- Gateway channels: the run continues in the background and the completed report is delivered back to the originating conversation.
- Local archive: every completed result is saved under
<workspace>/deep_research/for later use.
Use regular search for a single fact or URL. Use Deep Research for comparisons, landscape reviews, technical investigations, and questions where source agreement matters.
Tracing makes Raven's reasoning path inspectable without sending trace data to a hosted service. Open the local dashboard with:
raven tracingEach session.turn becomes a trace tree containing the work that happened beneath it:
- LLM calls, models, token usage, cost, latency, and errors
- Tool inputs and outputs
- Subagent runs and parent-child relationships
- Skill reads and injections
- Memory recall, storage, extraction, and consolidation
- Large prompts and results stored as out-of-line artifacts
Tracing is enabled by default and is designed to never interrupt Raven's control flow. Spans are stored locally at ~/.raven/traces/logs/audit-spans.log; set RAVEN_TRACING_DIR to move the state directory or RAVEN_TRACING=0 to disable recording.
The schema follows a small, versioned semantic contract. See the Tracing Standard API for span names, attributes, artifact behavior, and extension rules.
| System | What it adds |
|---|---|
| EverOS memory | Durable user memory, agent memory, and world knowledge across sessions |
| Context Engine | Explicit token budgets and a unified assembly pipeline that preserves the most useful context |
| Proactivity | Sentinel observations, scheduled work, nudge policy, and deferred decisions |
| SkillForge | Built-in, workspace, EverOS, and mirrored skills with retrieval, feedback, and evolution |
| Evolver | Reproducible evaluation loops for improving agents and reusable procedures |
| Agent Templates | Shareable starting points for specialized digital workers built on the same harness |
Raven supports API-key, OAuth, local, and OpenAI-compatible providers. The onboarding catalog includes OpenRouter, OpenAI, Anthropic, Gemini, MiniMax, DeepSeek, Z.ai, DashScope, Moonshot, VolcEngine, SiliconFlow, Groq, AiHubMix, Azure OpenAI, GitHub Copilot OAuth, OpenAI Codex OAuth, Ollama, and hosted vLLM.
Twelve gateway adapters connect Raven to Telegram, Slack, Discord, WhatsApp, Matrix, Feishu, WeCom, Mochat, QQ, DingTalk, Email, and WeChat.
raven channels list
raven channels enable <adapter>
raven gateway| Command | Purpose |
|---|---|
raven or raven tui |
Launch the terminal UI |
raven agent -m "..." |
Run a one-shot task |
raven onboard |
Configure providers, sandboxing, channels, memory, research, and import |
raven status |
Show configuration and runtime status |
raven doctor |
Diagnose provider and environment problems |
raven tracing |
Open the local trace dashboard |
raven sessions list |
Browse, resume, fork, export, or delete sessions |
raven skill list |
Inspect the local SkillForge catalog |
raven sentinel status |
Inspect proactive memory and scheduled nudges |
raven cron list |
Inspect scheduled jobs |
raven gateway |
Run messaging gateways |
raven upgrade |
Upgrade a managed installation |
Run raven --help or raven <command> --help for the complete CLI surface.
- Documentation index
- Developer workflow
- Tracing Standard API
- Sandbox usage
- Memory plugin architecture
- Self-evolution loop mapping
- Proactivity implementation
CLI / TUI / Messaging Gateways
|
v
TUI-RPC / Spine
|
v
Agent Loop
+-------+-------+
| | |
Providers Tools Subagents
| | |
+--- Context Engine ---+
|
+-------+--------+
| |
EverOS Memory SkillForge
| |
+--- Proactivity + Evolver
The Python runtime and React/Ink TUI communicate only through typed TUI-RPC. The Spine carries runtime events, while the Agent Loop coordinates providers, tools, context, memory, skills, subagents, and proactive work.
Key directories:
raven/agent/ agent loop, tools, and subagents
raven/channels/ messaging adapters
raven/context_engine/ context assembly and token budgeting
raven/memory_engine/ EverOS integration and local skill memory
raven/proactive_engine/ sentinel, scheduling, and nudges
raven/providers/ model providers and routing
raven/skill_hub/ external skill retrieval
raven/tracing/ instrumentation, storage, and viewer
raven/tui_rpc/ typed runtime-to-TUI boundary
ui-tui/ React/Ink terminal interface
Raven is part of the EverMind open-source ecosystem. Explore EverOS, EverAlgo, HyperMem, EvoAgentBench, EverMemBench, and EverMe.
Issues and pull requests are welcome. Start with the developer workflow, follow AGENTS.md for repository rules, and use GitHub Discussions for design conversations.