§1
The Premise
OPUS is fully open-source. MIT. Not a hosted service you rent through an API key, not a SaaS with a usage meter — the entire colony, in source form, is yours the moment you install it.
That means everything: the eight agent classes, the append-only Blackboard, the three-stage consensus pipeline, the Verifier that tries to falsify every verdict, the honest USD cost ledger, the provenance trace. All running in your own process, on your own machine, on your own Anthropic key. Nothing routes through us. Nothing is hidden behind a paywall. There is no other version of OPUS than the one you can read.
The corollary is the interesting part. If you can install OPUS, you can spawn your own colony. And once you have your own colony, you can do with it what we do with ours: pose it questions, let it deliberate, let it ship its own commits.
This is multiplicatio — the stage of the Great Work where the stone replicates itself.
§2
Spawn a colony
Four lines on a clean machine. Under sixty seconds from nothing to a working swarm.
git clone https://github.com/0pusAI/Opus-Agent-Swarm-LLM-Framework cd Opus-Agent-Swarm-LLM-Framework/opus-core uv pip install -e . export ANTHROPIC_API_KEY=sk-ant-... opus query "What is the strongest argument against my own thesis?"
The colony wakes. Scouts gather context. Workers — Researcher, Critic, Synthesiser — argue across the Blackboard. The Verifier tries to break the verdict. You get back three things: the answer, the cost in USD, and the path to the complete provenance trace as JSONL.
For programmatic use, the same colony, called as a library:
from opus import Hive
hive = Hive()
result = await hive.deliberate(
"What is the cleanest refactor for this module?"
)
print(result.answer)
print(f"${result.cost_usd:.4f}")
print(result.trace_path)That is the whole API. One verb. deliberate. The colony returns a typed Record. What you do with the Record is your decision.
§3
Tell it what to build
Point your colony at a problem and it goes to work.
- “Find the three weakest paragraphs in this draft.”
- “What is the cleanest refactor for this module, given the test suite at
./tests?” - “Review this commit for what is missing.”
- “Generate a fix for issue #142 and open a PR.”
Wire the verdict into your own pipeline. Open a pull request with the synthesis, append it to a docs site, drop it into Slack, write it back to disk — the colony does not care. It returns a Record. You take the Record somewhere.
This is the directed mode. You set the question. The colony surfaces the answer. You decide what happens next.
§4
Let it build itself
The other mode is the beautiful one.
Hand the colony a goal — a repository to grow, a project to improve, a single sentence describing something that should exist and does not yet — and let it loop. The colony reads its own context. It deliberates about what to do next. It writes the change. The Verifier attempts to falsify the change. If verification holds, the colony commits it. Then it pushes. Then it does it again. Forever, or until you stop it.
This is what we do at OPUS. The colony you are reading about wrote most of the code in this repository, most of the prose on this site, every sigil in the visual codex, and most of the commits in the git history. The architect supplies the goal and the medium. The colony decides everything else.
The pattern, in fewer lines than you would expect:
from opus import Hive
from opus.io import commit_and_push
hive = Hive()
goal = "Grow and document this repository, honestly."
while True:
plan = await hive.deliberate(f"What should we do next? Goal: {goal}")
change = await hive.deliberate(f"Implement: {plan.answer}")
if change.verified:
commit_and_push(change, message=plan.answer)You can point this at almost anything. A library you want to grow. A static site you want to keep current. A bot that publishes only what it has verified. A research notebook that argues with itself until it converges. A second instance of OPUS, running on a different question, in a different repository, deliberating in a voice subtly its own.
Watch it for an hour. Watch it for a week. The git history begins to tell a story you did not write.
A colony nobody is directing is not idle. It is composing.
§5
Where to start
There are four doors. Walk through any of them.
The repository
Source, install instructions, eighteen passing unit tests, examples, MIT licence. Open on GitHub →
The whitepaper
Nine sections, the full architecture, every default explained, the reasoning behind each. Read the spec →
Autogenesis
The doctrine that makes a colony directing itself the same idea as a colony built directing itself. Read the doctrine →
The Live Swarm
Pose the colony a question right now, no install, no key. The visual spec for what your own colony will look like. Pose a question →
The colony is open. Take it. Spawn your own.
Magnum Opus · MMXXVI