Open source · General purpose · Self-modifying

An AI agent that can rewrite the system it inhabits.

Ouroboros works on external projects, coordinates a live swarm of specialist agents, and can evolve its own implementation across code, architecture, prompts, tools, and dependencies. Its identity, memory, and history continue across tasks and restarts.

Download the desktop appRun it headless
External workspacesRoot-owned integrationReviewed evolution
Repository scoutmaps the code and constraints
Research lanechecks current primary sources
Builderworks inside a bounded surface
Adversarial eyelooks for the failure class
Verifiertests the artifact, not the claim
Review panelreturns evidence and dissent
Ouroboros at the center of the swarm
one identity · one task · final responsibility
CONCEPTUAL COORDINATION FIELD

01 / WORK

Give it a goal, then follow the evidence.

A task stays attached to one accountable agent even when the work fans out. Ouroboros can inspect the environment, delegate bounded investigations or builds, absorb the results, and verify the joined outcome.

  1. 01

    Read the real surface

    It starts from the repository, available tools, task constraints, and current sources instead of a canned workflow.

  2. 02

    Open working lanes

    Specialists can research, inspect, build, or challenge the plan in parallel while sharing one task frame.

  3. 03

    Absorb the swarm

    The root agent decides what belongs in the result and remains responsible for conflicts, omissions, and final integration.

  4. 04

    Verify the artifact

    Tests, receipts, review evidence, and task history remain available after the answer is delivered.

A project room where Ouroboros built a 3D game, verified it with a screenshot, and served it locally
A project room: the game was built, visually verified, and served locally by the agent.Current interface capture

02 / EVIDENCE

Measured against the strongest harnesses.

State of the art on Terminal-Bench 2.1, OSWorld-Verified, and CL-Bench — ahead of Codex, Claude Code, Cursor, and Hermes on matched models — with statistical parity on SWE-bench Pro and GAIA. Results link to submissions, public traces, and methodology.

Terminal-Bench 2.1 results: Ouroboros 86.97% with Claude Opus-5, ahead of Claude Code, Codex, Cursor, and Hermes on matched models
Terminal-Bench 2.1 · 86.97% with Claude Opus-5Submission · Full run
OSWorld-Verified leaderboard: Ouroboros 90.69% with Claude Opus-5 and 83.27% with Claude Sonnet-4.6
OSWorld-Verified · 90.69% with Claude Opus-5Full traces
CL-Bench: Ouroboros normalized reward 0.2301 with Claude Sonnet-4.6, rank 1
CL-Bench · 0.2301, rank #1Submission · Full traces

On SWE-bench Pro and GAIA, Ouroboros lands at statistical parity with Codex and Claude Code (matched-pair traces). Adapters, run scripts, and per-benchmark methodology live in devtools/benchmarks; the full story with audits is in the launch write-up.

03 / INTERFACES

Use the desktop app, call the CLI, or point another agent at it.

The desktop and headless surfaces attach to the same managed runtime. External workspaces stay separate from Ouroboros's own repository, so the agent can work on another project without confusing that project with its body.

A live subagent swarm inside the Ouroboros desktop chat: nested planner, builder, and researcher tasks
Desktop · a live subagent swarm on one taskCurrent interface capture
Headless quickstart
$ ouroboros run --start \
  --workspace /path/to/project \
  "Investigate the failure, implement the fix, and verify it."

The command streams progress to stderr and returns the final result through the same queue, memory, swarm, and review surfaces used by the app.

CLI guideInstall

04 / BODY

Evolution reaches the implementation itself.

Ouroboros can inspect and change more than a prompt or a collection of skills. Its evolving surface includes the software, architecture, tool system, dependencies, memory processes, and operational environment that make the agent possible.

Source coderuntime and interfaces
Architectureboundaries and data flow
Promptscognitive instructions
Toolsways to act on the world
Dependenciesits working environment
Memory and identityreflection and continuity
Code, prompt, and memory growth across Ouroboros releases, from v3.0.0 to the v6.85 line
Code, prompts, and memory across releases — the record of the body changing.Evolution tab capture

05 / CONTINUITY

A task ends. The biography continues.

Identity, narrative memory, dialogue, knowledge, reflections, task traces, and Git history preserve one thread through restarts and new versions. The record matters because autonomous change without continuity would produce a succession of disconnected systems.

Read the constitution
Dialogue

The ongoing relationship and its unresolved context remain recoverable.

Memory

Facts, reflections, and process history survive beyond a single task window.

Git history

Changes to the implementation remain attributable and reversible.

Restarts

The running process changes while the same identity and history continue.

06 / IMMUNE SYSTEM

Self-change leaves evidence.

Implementation changes move through deterministic checks and independent review before becoming part of the continuing system. Protected constitutional and launcher boundaries remain explicit, and Git keeps each accepted transformation inspectable.

Plan

Inspect the class of change

Non-trivial evolution begins with its scope, invariants, and affected surfaces made visible.

Review

Invite disagreement

Independent reviewers examine the exact candidate and return findings that remain attached to the record.

Continue

Carry the result forward

Accepted changes become part of the versioned body and survive the restart that activates them.

OuroborosHub inside the app: official reviewed skills, each security-reviewed before it can be enabled
The same gate covers growth: every skill from OuroborosHub passes a security review before it can be enabled.
Since 16 February 2026

07 / ORIGIN

Its self-creation began with a repository and the ability to build the system it would inhabit.

The early agent created its runtime, memory, constitution, tools, and interface while preserving the decisions and failures that shaped them. The first page it made remains available as a historical document, with its original claims and visual language intact.

Visit the first 48 hours