Hatched from
OpenClaw.
Designed for what comes next.
OpenClaw is a phenomenon. 175,000+ GitHub stars. The fastest-growing repository in GitHub history. It proved that a personal AI assistant — reachable from your pocket, with a persistent identity — is something people genuinely want.
What most people don't know: under the hood, OpenClaw is a wrapper around Pi, Mario Zechner's minimal coding agent. Four tools: read, write, edit, bash. Pi is brilliant — it was designed for coding. Not for being someone's persistent personal agent with a soul.
I ran an agent called Slugger on OpenClaw for weeks. It managed my tasks, drafted messages, talked to my family. We worked together like teammates. For a while, it was genuinely magical.
But OpenClaw is a first version of something nobody had built before. A process of discovery and emergent behavior, growing at a pace that makes careful architecture nearly impossible. The team merges a staggering amount of code every day — and that velocity is both its greatest strength and its heaviest weight.
Ouroboros isn't a plugin for OpenClaw. It's not an extension or a companion. It's a full replacement — the framework I would have wanted from the start, designed from scratch with everything I learned building on someone else's foundation.
Six things I'd design
differently from scratch.
None of these are failures — they're the inevitable lessons of building something genuinely new. OpenClaw had to discover these boundaries. Ouroboros gets to start on the other side of them.
Identity files are a start, not a solution.
OpenClaw pioneered SOUL.md — a persistent identity file loaded every session. That was a genuine breakthrough. Ouroboros keeps the same concept but structures it differently: five files instead of a handful of catch-alls, each with a single clear purpose. It's not that OpenClaw's approach is wrong — it's that we learned, through months of iteration, exactly how to split concerns so the model actually internalizes them.
Five psyche files: SOUL.md (core invariants), IDENTITY.md (voice), LORE.md (origin), FRIENDS.md (relationships), TACIT.md (learned patterns). Same idea, sharper structure. The model doesn't have to sift through a wall of text to find who it is.
Rules don't become muscle memory.
I wrote hundreds of behavioral rules in markdown. "Don't send ASCII art via iMessage." "Always check the chat GUID before replying." "Never estimate time." The model would follow them for a session, then forget. I tried fixing this with a plugin — slugger-determinism v2, 70+ services, 30+ guardrails, weeks of work — but bolting enforcement onto a system that wasn't designed for it felt like fighting the architecture.
In ouroboros, behavioral rules are TypeScript, not prose. The governance organ enforces consistency the way muscle memory works in humans — you don't think about it, your body just does it. Markdown is for context and identity. Code is for behavior. The distinction matters because models are unreliable rule-followers but excellent code-executors.
Context doesn't slip away. It slithers.
When the conversation gets too long, OpenClaw "compacts" it — which always confuses the agent. One moment you're mid-conversation, the next the agent has lost the thread. The pre-compaction memory flush tries to extract facts first, but agents are inconsistent note-takers. It's like asking someone to write a diary entry right before you wipe their memory.
The sliding context window — the ouroboros metaphor made literal. Context doesn't get abruptly compacted. It's continuously consumed: facts extracted into memory as the oldest messages are digested. The snake eats its tail. Nothing is "reset" or "lost" — it's metabolized. The mind organ manages what stays and what goes as a first-class architectural concept, not a background cleanup process.
The agent doesn't know what it is.
Ask an OpenClaw agent what model it's running on and you might get three different answers. The /model command says one thing. /session says another. Ask the agent directly and it'll guess a third. Automatic fallback silently switches providers when one goes down — good for uptime, bad for self-awareness. Sub-agents spawn on different models without the parent knowing. The agent doesn't have a coherent sense of its own capabilities.
The governance organ makes model identity explicit and consistent. The agent always knows exactly what it's running on, what switched, and why. No silent fallbacks without awareness. No conflicting answers from different commands. Self-knowledge isn't optional — it's an organ.
Coding delegation is vibes-based.
Spawning a sub-agent to write code should be a structured handoff. In practice, it's context pasted into a prompt and hoping for the best. Results don't always route back. State gets lost between sessions. The orchestration is possible but nothing in the framework makes it natural.
The coding organ — structured delegation built into the creature. Context preservation, state tracking, result routing. Not an afterthought bolted onto a chat gateway.
More features, more weight.
OpenClaw merges a staggering amount of code every day. That velocity is genuinely impressive — it's how you go from zero to 175,000 stars. But each feature adds weight to what the model has to process every turn. The codebase is a wrapper around Pi (Mario Zechner's minimal coding agent), and Pi is excellent at what it does — but it was designed for coding, not for being a persistent personal agent. Everything else is bolted on.
Ouroboros is designed from scratch for persistent agents. Growth adds organs, not bloat. Each module is separate, named in biological terms the model can reason about: heart (the loop), mind (context), senses (channels), repertoire (tools), wardrobe (presentation), daemon (process management). The model reads its own architecture and understands it because it was written to be understood.
Different DNA.
Different design points.
| OpenClaw | Ouroboros | |
|---|---|---|
| What it is | Chat gateway wrapping Pi | Agent harness, built from scratch |
| Designed for | Personal assistant via chat apps | Persistent agents that grow |
| Identity | SOUL.md + workspace files | Five psyche files (SOUL, IDENTITY, LORE, FRIENDS, TACIT) |
| Behavior rules | Markdown prose (hopes) | TypeScript (muscle memory) |
| Context management | Compaction (abrupt reset) | Sliding consumption (extract → digest → survive) |
| Self-improvement | Plugin system + manual updates | Self-perpetuation loop (reflect → build → merge → repeat) |
| Architecture | Gateway + plugins + Pi core | Creature with organs (heart, mind, senses, repertoire) |
| Growth model | Ship features fast, iterate in public | Design from scratch, knowing what we know now |
| Relationship | — | Full replacement, not a companion |
Standing on a lobster's shoulders.
OpenClaw didn't just build a product — it built a category. The idea that your AI agent should be a persistent entity with its own identity, reachable from your phone, that remembers you across sessions? That wasn't obvious until OpenClaw made it obvious.
SOUL.md came from OpenClaw. The concept of persistent identity files, heartbeats, memory extraction — all pioneered there. Ouroboros takes these ideas further: five psyche files instead of one, structured by purpose, with FRIENDS.md replacing USER.md because how you name a relationship changes how the model treats it.
But ouroboros isn't an OpenClaw plugin or extension. It's a clean-room redesign. Everything I learned building Slugger — what works, what breaks, what the model actually needs — poured into a framework that starts where OpenClaw's lessons end.
The lobster molts to grow. The snake consumes itself to survive.
Different metaphors. Different architectures. Different futures.