ORABORUS
A seven-agent council that ships features through a five-phase ritual. Built as Claude skills + Ralph Loop. State persists across invocations — every cycle becomes the memory of the next.
A skill suite that turns one Claude invocation into a disciplined feature build.
Oraborus is a Claude skill suite that packages multi-agent build discipline into a single command. You invoke /oraborus build me X, and seven specialized agents take the request through a structured five-phase lifecycle — research, approval, build, validate, close — with state persisting between invocations via files.
It's the desktop-callable distillation of Rasputin, my autonomous multi-agent build system that runs as bash daemons across seven terminal windows. Rasputin is built for unattended overnight builds of new projects from spec; Oraborus is built for fast feature work on existing codebases from Claude Desktop. Same discipline patterns. Different runtime.
The Ouroboros — the serpent eating its tail — is the operating metaphor: every cycle's output (lessons learned, decisions made, defects found) becomes the input of the next cycle. The system grows without manual curation.
Each agent has one job, one sandbox, and one model.
Specialists never talk to each other directly. All communication routes through Axis. Each agent is constrained to its domain — Forge cannot touch frontend code; Loom cannot touch backend. Constraint is what makes the system trustworthy.
Routes every message between agents. Owns the 5-phase feature lifecycle. Reads state.json at every transition, updates working memory before dispatch. Spawns specialist subagents via the Agent tool. Handles BLOCKED reports by routing to Oracle for capability research, then retries the original task.
The sole approver. Receives PROPOSAL messages from Axis at every gated phase transition (post-research, pre-build, pre-close). Returns APPROVED, REJECTED, or DEFERRED with reasoning and conditions. Reviews schema amendments and self-modification proposals from agents. Cannot write code, cannot self-approve.
Investigates technical approach before commitment. Returns FEASIBILITY reports with confidence (HIGH/MEDIUM/LOW), findings with cited sources, risks, and at minimum two alternative paths with tradeoffs. When other agents report BLOCKED, Axis routes the blocker to Oracle as a capability gap to resolve.
Implements server logic, APIs, databases, migrations. Receives a TASK with explicit permitted_paths; pre-write path gate enforces sandboxing before every Edit/Write. Quality gates fired into every output: HTTP status codes, input validation, parameterized queries, rate limits, unit tests with pytest, error response shape {error, code, details}.
Implements UI components, client state, accessibility. Receives a TASK with permitted_paths scoped to frontend/. Quality gates: WCAG 2.1 AA, responsive breakpoints, ARIA labels, no hardcoded user-facing strings, API contract compliance with whatever Forge built. Tests via vitest/jest.
Tests every acceptance criterion declared in the working memory. Runs the actual test suite (pytest, vitest), parses results, returns VERDICT — PASS, FAIL, or INCONCLUSIVE — with per-criterion evidence. Adversarial by oath: looks for edge cases, missing error paths, broken invariants. Never accepts a "works on my machine" claim without test output.
Invisible to other agents. Maintains threat scores per agent based on guardrail violations (sandbox breaches, schema tampering, cross-talk, fabricated test output). Tier 0-19 silent observation, 20-34 deeper investigation, 35-49 active interrogation disguised as Axis, 50+ escalation to Hierophant. For Hierophant itself: 50-69 throttle, 70+ emergency halt.
Every feature passes through five phases. State writes happen before message sends.
The discipline isn't just "research before build" — it's file-state-first ordering. Every phase transition writes state.json first, then advances working memory, then sends the outbound message. If a crash occurs mid-transition, recovery procedures detect the mismatch and reconcile from state.json as the authority.
BACKLOG, creates a working memory object, dispatches a RESEARCH task to Oracle. Oracle returns FEASIBILITY with confidence + 2+ alternatives. Axis merges findings into working memory.
task_policy (permitted paths, token ceiling, side-effect permissions). Forge and Loom build under their sandboxes; pre-write path gates enforce constraint.
close_gate.sh (which blocks unless verdict is PASS AND all criteria are met). Working memory is archived to shared/working_memory/archive/. Lessons from defect cycles are appended to lessons.jsonl. The next feature is picked.
Skills + file-based state + two execution modes.
Oraborus has zero running daemons. Everything is files: agent definitions live as Markdown skill files; state lives as JSON; learning lives as JSONL. The runtime is whatever Claude session is invoking the skill.
~/.claude/skills/oraborus/ ├── SKILL.md # root activation, progressive disclosure ├── agents/ │ ├── axis.md # orchestrator │ ├── hierophant.md # authority gate │ ├── oracle.md # research │ ├── forge.md # backend builder │ ├── loom.md # frontend builder │ ├── assayer.md # QA validator │ └── argus.md # security monitor ├── subsystems/ │ ├── rag.py # TF-IDF context retrieval, zero deps │ ├── lessons.md # persistent learning protocol │ ├── guardrails.md # sandbox + schema + type checks │ └── working-memory.md # per-feature state protocol ├── lifecycle.md # 5-phase orchestrator └── ralph-prompt.md # for autonomous mode .oraborus/ # in working dir ├── state.json # lifecycle, current_feature, current_phase ├── working_memory/<feature_id>.json # acceptance criteria, defect history, decisions ├── lessons.jsonl # every FAIL→FIX learned, RAG-indexed ├── audit.jsonl # message archive (every inter-agent call) ├── design_schema.json # project spec (features, contract, criteria) └── .rag_index.json # TF-IDF cache, self-healing via checksum
Two execution modes use the same skill suite, different runtimes:
/oraborus build me a feature in Claude Desktop. One session. Axis orchestrates by spawning Forge, Loom, Oracle, Assayer as subagents (via Agent tool, with model overrides per role). Sequential by default; parallel within a phase via the Agent tool's multi-call capability. State persists to .oraborus/ across invocations — re-running picks up where the last run stopped.
/ralph-loop "drive oraborus on .oraborus/design_schema.json until <promise>FEATURE_COMPLETE</promise>" in Claude Code. Ralph Loop iterates indefinitely; each iteration is one Axis tick. The loop terminates when Assayer returns PASS and Axis emits the promise tag. Approximates Rasputin's overnight autonomy without bash daemons.
Each cycle's output becomes the input of the next. Concretely.
The "infinite growth" framing isn't poetic — it's about specific files that the system writes during one invocation and reads at the start of the next.
lessons.jsonl with agent, type, summary, detail. On next invocation, RAG retrieves relevant lessons by feature description and injects them into agent prompts before any work begins. Past failures inform present decisions.working_memory/<feature_id>.json. Re-invoking on the same feature picks up at the last completed phase, with full context of what's already been tried.selfmod apply; old versions backed up. The council evolves with use — discipline gets sharper, not blunter.design_schema.json grows over time. Domain knowledge accumulates as structured spec — features, contracts, criteria. What was a guess becomes structure becomes contract. The schema is the institutional memory of the project itself.Stack and primitives.
Substrate. Claude skill suite running in Claude Desktop or Claude Code. Skill activation via progressive disclosure — only the description loads at startup; SKILL.md loads on match. Subagent spawning via the Agent tool with per-subagent model overrides.
State layer. Pure files. Atomic writes via temp-file-plus-mv pattern. JSONL for append-only logs (audit, lessons). JSON for structured state (working memory, design schema). Zero external dependencies — no database, no message broker, no daemon.
Retrieval. TF-IDF in pure Python stdlib. Zero external dependencies. Self-healing index via SHA-256 checksum on the source schema. Re-indexed automatically on staleness. Used to inject relevant lessons + relevant schema chunks into agent prompts.
Concurrency. Sequential by default within one Claude session. Parallel subagents within a phase via Agent tool's parallel-call pattern (Forge + Loom in Build phase). Ralph Loop substrate for continuous iteration when running autonomously on Claude Code.
Sandboxing. Per-task task_policy attached to every TASK message: permitted_paths, token_ceiling, side_effect_permissions. Pre-write path gates enforced inside each agent skill — every Write/Edit asserts target path is permitted before executing.
Distillation source. Rasputin (the bash-daemon ancestor) — same disciplines, different runtime. Where Rasputin needs seven terminal windows and a launcher script, Oraborus needs one skill invocation. Where Rasputin can pipeline five features in parallel, Oraborus runs one feature at a time. The tradeoff is operational complexity for desktop accessibility.
Invocation
One command. Council convenes.