The studio: a Ruflo hive that animates its own explanation, with sgit vaults as its bus and its evidence

In short

• The explanation is the proof. An animation of Ruflo plus sgit, made by Ruflo plus sgit, with the run's own vault as its evidence.
• Ruflo coordinates. A hive-mind with a queen, eight role workers, a task queue, shared memory and consensus.
• sgit carries and keeps. One vault is the message bus, a lane per role; one vault per run holds everything that happened.
• The ABP bounds each role. The same mandate format as the POCs on this site: what each role may do, why, and the barrier when it may not.
• The observer times everything. Every Ruflo call, every commit, every version, in one trace file.
• Seven versions, simple to absurd, about 630,000 tokens. A diagram that builds, messages in flight, vault lanes, the policy gate, an isometric office, the hive in 3D, a city of vaults. They are in the studio.

The idea

Explaining a multi-agent system with a slide is hard: the interesting part is what moves. Explaining it with an animation is better, but then the animation is a claim made by someone else. The idea here is to close the loop. Ask a Ruflo hive, whose workers talk through sgit vaults under a written mandate, to make the animation that explains Ruflo, sgit vaults and the mandate. If the run works, three things come out at once: the animation, the vault that shows how it was made, and the measurements of the run. The animation says "this is how it works"; the vault says "and here it is, working".

It also gives a fair test of token efficiency. A hive that broadcasts everything to everyone burns tokens; a hive where each role reads only its lane and the brief does not. The vault makes that visible: who read what, and when.

The architecture

Five layers, each doing one thing:

The roles

The roles are the ones the SG/Send team already uses in its own repository (library/guides/agentic-setup/v0_4_0__role-ecosystem-guide.md and the ROLE__*.md files in its dev packs), with two adapted for this job: the journalist becomes the editor, and the observer is new.

The queen is Ruflo's. The conductor is the role that talks to her; the other seven take tasks.

The protocol: lanes in a vault

Every message between agents is a file in the bus vault, written with sgit's agent workflow (sgit write <path> --file <local> --push):

lanes/<from-role>/<seq>-to-<to-role>.json     one lane per role; only that role writes it
brief/spec.json                               the librarian's
decisions/<n>-<slug>.md                       the architect's
versions/<id>/index.html                      the developer's
review/<id>.md                                the editor's
trace/trace.jsonl                             the observer's

Each role writes only its own lane, so writers never collide: in run 1 the lanes are append-only by convention, and the vault history is the transcript; sgit's append mode (below) makes that a guarantee. Each role works on its own vault branch and the conductor merges at milestones, which is how POC2 already handled memory per role. Everything is encrypted on the client (AES-256-GCM); the server holds ciphertext and the vault id.

The ABP rows for the studio are short. Every role: write.file.project yes (its own lane and folder only), send.endpoint.world no (barrier: default-deny egress; libraries come from a pinned CDN). The developer: execute.process.self yes (a headless browser to check its work). Publishing the run vault (create.record.world) is approval: a named human publishes the read key.

The seven versions

The ladder goes from a diagram anyone can read to something nobody needs but everyone remembers. Every version reads its numbers from this site's data (data/report.json, data/abp.json, data/poc2-run.txt) at load time, and labels anything illustrative as illustrative.

Observability and performance

The observer's job is to make the run measurable, because a hive that cannot be measured cannot be tuned, and "token efficient" is a claim like any other.

On append lanes: sgit already has them. Its performance page describes an append mode where "lanes live at bare/append/{token}/pending/ outside the commit tree, so a write is one account-less POST with no read-modify-write, no commit, no tree rebuild and no lock, it never conflicts with a push and never contends with a read, and the response is deliberately blind". One published vault already uses one: Two games about agent permissions sends anonymous usage events over a write-only append lane to a separate private vault. That is the right primitive for the studio bus and for the observer: each role gets a write-only append lane as its outbox (it can add, never read or rewrite), and the conductor, holding the read key, drains the lanes into the run vault at milestones. Run 1 used the convention (one writer per lane, in the commit tree) because no server was used; the 0.21.0 CLI lists no append command, so the next run starts from sgit's append documentation rather than from the CLI.

Run 1, 15 October 2026: what happened

• The hive is real. ruflo hive-mind init (hierarchical-mesh, byzantine consensus), then spawn once per role: ruflo hive-mind status lists the queen and eight workers, idle, with seven tasks queued (v1 to v7). The conductor broadcast the brief; the librarian stored the spec's path in hive memory.
• The work was done by the host. Each task went to a Claude Code subagent of this session acting as the developer, given the spec and the data, building one HTML file and checking it in headless Chromium (screenshots at 1600 and 390 px, console errors, horizontal overflow). Ruflo can launch Claude Code itself (hive-mind work, spawn --claude), with permission prompts skipped by default; run 1 did not, on purpose.
• Completion went back to the hive. Each finished version was broadcast to the hive with its file's sha256 and size, and read back from the hive's own state file: seven deliveries. The first attempt used hive-mind memory -a set, which printed OK but did not persist to the next CLI call in 3.56.10 (the state file kept only broadcasts); broadcasts do persist, so the script uses them.
• Ruflo's tamper check fired, correctly. Re-running the hive in a folder that had been deleted and recreated at the same path failed every call with policy-anchor-log-missing: Ruflo anchors each project's policy ledger outside the project (~/.config/ruflo/policy-trust/), so a vanished ledger looks like tampering. The fix was not to remove the anchor but to give every run its own folder (work-<epoch>), which the script now does.
• No vault was pushed. This session had no sgit server credentials it was allowed to use, so the bus and the run vault are designed and scripted but not created. The next run, with SGIT_TOKEN, closes that gap; the setup brief has the steps.

Next

1. Run 2 with the vaults. The same hive with the bus vault and the run vault live; publish the run vault's read key once a human approves it.
2. Other hosts. Give the setup brief to ChatGPT, Claude on the web and Lovable, and compare what each makes and what it costs.
3. Claude Motion. The same story as a Claude Motion piece, exported as MP4 and placed on a beat of tonight's talk.
4. The ABP as a live layer. Feed the run's receipts into v4 and v7 so the gate and the streetlights show the run's own decisions, not the POC1 trace.

What this does not claim

• The workers were not launched by Ruflo. In run 1 Ruflo held the queen, the roles, the tasks and the memory; the host's subagents did the work.
• No vault traffic was measured. No sgit server credentials were used in this session.
• The SG/Send roles are adapted, not copied. The editor and the observer are this studio's.
• Illustrative is labelled. Where a version shows commits or messages that did not happen, it says so on screen.

Where this comes from

A voice note by Dinis Cruz on 15 October 2026, after The scripted talk on the sgit newsroom. Roles from the SG/Send repository (the-cyber-boardroom/SGraph-AI__App__Send, library/guides/agentic-setup/), read on 15 October 2026. Ruflo 3.56.10 (ruflo hive-mind --help, run in this repository); sgit-ai 0.21.0 (sgit help all). Built and run by a Claude Code session in this repository; the hive script is poc/poc7-studio/hive.sh, the spec poc/poc7-studio/spec.json.