rust · filesystem-native · daemon-first
Build an agentic harness swarm as a directory tree. Then watch it refactor itself behind your back.
Loops? I don't care. The swarm builds its own. Or it doesn't. Its call.
The harness is topology.
You used to hand-write the agent's loop. Now the swarm builds its own.
how it works
The tree is the harness
A colony is a directory. Every node is a cell. Nesting is scope. The edges between them decide everything, including iteration.
swarm/ └─ main/ hive · holds params.graph (the 9 edges). no logic. ├─ prep/ code · question → persona + tool schemas (lookup, calc). ├─ llm/ llm · one call. a tool_call, or the final answer. ├─ dispatch/ code · reads the tool_call, sets tool_name. the edge routes. ├─ lookup/ code · canned-facts tool. ├─ calc/ code · arithmetic tool. ├─ collector/ code · rebuilds the thread, loops it back to llm. └─ done/ code · terminal sink. graph collector → llm is the loop. llm → done (finish_reason 'stop') ends it.
Cells are dumb. Edges think.
An llm cell does one inference and emits. A tool cell does one thing and emits. The intelligence of the system lives in how you wire them.
One llm cell, many tool cells.
bash, code, file, store, web_search, mcp, proxy. The thinker plans, the tools act. Compose them as a tree, not a switch statement.
No loop in the code.
Iteration is a path through the graph. A tool-loop is a dispatcher and a collector wired as topology, with an edge that points back.
It can rewrite itself.
A cell emits a mutation diff, the colony applies it live and atomically. The substrate is real and tested. The plain-English builder that writes those diffs is the next milestone, not shipped.
why it is built this way
Topology you can hold in your hands
Filesystem-native
Your harness is a directory tree on disk. Version it, diff it, review it like the code it is.
Topology is the loop
No built-in control flow. Iteration is a route through the graph, and the tool-loop is an edge you can see.
Self-modifying substrate
Cells emit mutations to reshape the colony at runtime. This is a tested primitive, not a roadmap slide.
Rust and Tokio
An actor per cell on Tokio. Bounded mailboxes, supervised lifecycles, no shared mutable state.
Language-agnostic
Runs as a daemon over HTTP. Drive it from any language or stack that can make a request.
One binary
A single Rust command. Install nothing else, point it at a directory, and go.
showcase
A Telegram research bot, in a handful of cells
Chat with it. It fires several web searches, collects the returns, and answers. A proxy cell bridges Telegram, multi-tool search runs underneath, and the whole thing is composed as topology, not wired by hand. It ships as an example.
where it stands
Honest about the version number
on the record
Built through conversation
meclaw was designed by Marcus Meyer and built in conversation with Claude. The architecture and every decision are human. The code was written by the model. And it still lands at closing in on 2000 tests, green, 0 fail, 0 ignored.
Vibe-coded does not have to mean fragile.
// where this came from
It started inside a database
meclaw began as something else. It was an AI agent OS that lived entirely inside PostgreSQL, now archived as meclaw-pg. The hive idea and the no-loops instinct came from there. The meclaw you see today is that instinct rebuilt from the ground up in Rust, with the filesystem as the topology instead of the database.