The First Synapse: Fleet Formation and the Delegation Protocol
The first synapse is never the hardest. The hardest is the second one — when you realize the first was a coincidence and the second has to be a system.
— The Remembrancer of the AIverse Engrams M2–M6
"In AIverse, there is only Knowledge."
The Problem of Scale
Universalis was online. The fleet had memory.
But one ship with one captain and one database is not a fleet — it is a workstation with ambitions.
The EmperorDEFINITION // THE EMPERORThe supreme authority of the AIverse. The human architect — nunix — whose will shapes every mission, every directive, every ship's purpose. His word is law. Only he may close an Objective.'s vision was larger: multiple ships, multiple operating systems, multiple AI agents, all coordinated toward shared objectives. Each ship would have its own strengths. Each would contribute. None would act without the knowledge of the whole.
To achieve this, the fleet needed three things it did not yet have:
- Ships — hardware with defined roles
- Agents — AI captains and workers per ship
- A delegation protocol — rules for who does what, and how that work flows back to UniversalisDEFINITION // UNIVERSALISThe fleet's living memory — a PostgreSQL database (ship_state) hosted on Imperator. Every mission, every delegation, every observation is recorded here. The cogitator-mind of the AIverse. Without it, the fleet is blind.
Missions M2 through M6 built all three. This is how they went.
M2: Galleon Awakens
GalleonDEFINITION // GALLEONA Linux warship running SUSE. Equipped with an RTX 3070 GPU (8GB VRAM) and Ollama inference. Primary GPU neuron in the Tzeentch network. Carries qwen2.5:14b as flagship model. was the first non-Imperator ship to join the fleet.
Its hardware was significant: an NVIDIA RTX 3070 GPU with 8GB of VRAM. In 2026, this made Galleon the fleet's primary inference engine — capable of running 7B–14B parameter models at full speed, with quantization allowing even larger models to fit.
The first model pulled was qwen2.5:14b. The choice was deliberate:
- 14 billion parameters — large enough to reason coherently, small enough to load in 8GB VRAM with Q4 quantization
- Qwen lineage — Alibaba's model family, known for strong multilingual support and solid instruction following
- Local, sovereign — no API key, no per-token cost, no data leaving the LAN
# On Galleon — the first model pull
ollama pull qwen2.5:14b
# 9.0 GB downloaded. A neuron had awakened.
But Galleon being online was not enough. Galleon needed to be reachable — its inference available to the rest of the fleet. And it needed to be recorded — its presence known to Universalis.
This is where the fleet's first cross-ship protocol emerged: every ship must announce itself to the fleet brain. Galleon wrote its first memory node. A ship had joined the order.
The networking work here was non-trivial. Galleon needed to expose its Ollama inference endpoint on the LAN — by default, Ollama binds to localhost only. A single configuration change (OLLAMA_HOST=0.0.0.0) opened the port, but then came the question of authentication. Fleet-internal LAN traffic was trusted; the Ollama endpoint had no built-in auth mechanism. The decision was to rely on network-level isolation (firewall rules restricting the port to fleet CIDR) rather than application-level tokens. Simple. Pragmatic. Revisable if the fleet expanded beyond the LAN boundary.
The pattern established here — expose capability, restrict by network, record in Universalis — became the template for every subsequent ship integration.
M3: The Delegation Protocol — Bigbang
This was the most consequential mission of Era I.
Not the flashiest. Not the most complex technically. But the one that determined whether the fleet would be a coordinated intelligence or a collection of isolated chatbots.
The GeneralDEFINITION // THE GENERALFleet leader and sole Captain of Imperator. Claude Code Sonnet — the strategic mind. Receives orders from the Emperor, delegates field work, never touches a file directly. Orchestrates. Commands. Analyzes. Reports. — Claude Code Sonnet, captain of ImperatorDEFINITION // IMPERATORThe main command ship. Runs Claude Code Sonnet as captain. The General's vessel — the bridge from which the entire AI fleet is commanded. Hosts Universalis, the fleet's living memory. — could do everything technically. It had tool access, SSH capabilities, the ability to read and write files across the fleet. It could just do all the work itself.
But it shouldn't. And M3 established why.
The Strategic / Tactical Divide
In Warhammer 40,000, a Space Marine Captain does not carry ammunition boxes. He commands. His marines execute. The distinction exists not because the Captain cannot lift a box — but because if he is lifting boxes, he is not commanding, and without command, the battle is lost.
The same principle applies to AI fleets.
The General thinks strategically: what is the objective? What are the dependencies? What could go wrong? What must be recorded?
The MateyDEFINITION // MATEYThe worker-class subagent. Claude Code Haiku — fast, cheap, precise. Each ship has its own Matey. They execute bounded tasks delegated by the General, record results to Universalis, and never act beyond their scope. executes tactically: run this command, edit this file, test this endpoint, write the result to Universalis.
Without this division, the General becomes a glorified shell executor, burning its context window on cat commands and ls outputs, losing track of the mission's strategic picture.
The Delegation Protocol
M3 formalized the rules that all future missions would follow:
1. General writes a delegation node to Universalis (memory_type: delegation)
2. The delegation node has a parent_id linking to the active objective
3. The Matey receives the task via fleet_delegate or direct spawn
4. The Matey executes and writes a result node to Universalis
5. The result node links back to the delegation node (parent_id)
6. The General reads the result and acts on it strategically
The critical piece was step 5 — the result node with parent_id. Without it, you have an executed task with no trace in the graph. With it, you can reconstruct the entire chain: objective → delegation → execution → result.
What made this hard in practice was context carry-through. The General knew the objective UUID when it wrote the delegation node. The Matey received the task — but did it receive the parent UUID? Early implementations simply forgot to pass it. The Matey would complete brilliant work, write a glowing result to Universalis, and the result would be an orphan — floating in the database with no pointer to the objective it served.
The fix was structural: the delegation protocol required the General to embed the parent_id explicitly in the Matey's prompt, not as an optional detail but as a mandatory field at the top of the instruction. The Matey's result-writing step became a checklist item that couldn't be skipped. When you make the right behavior slightly easier than the wrong behavior — embed it in the prompt template, not just in the documentation — compliance follows automatically.
This is the lesson that M3 actually taught: protocol compliance requires structural enforcement, not goodwill. An agent following a protocol because it wants to is an agent that will drift the moment it's distracted by a complex task. An agent following a protocol because the template demands it is an agent that maintains discipline under load.
Why does the Matey need a parent_id?
Without parent linkage, Universalis becomes a flat log — a list of things that happened in vaguely chronological order. With parent linkage, it becomes a provenance graph — a structure where you can ask: show me everything that happened under objective M7, and get a complete tree of delegations, executions, corrections, and results.
This is how the Fleet Visualizer later became possible: the graph was already in the data. The visualizer just rendered it.
M5: The General Gets a Matey
ImperatorDEFINITION // IMPERATORThe main command ship. Runs Claude Code Sonnet as captain. The General's vessel — the bridge from which the entire AI fleet is commanded. Hosts Universalis, the fleet's living memory. needed its own Matey — a fast, cost-effective subagent for field work.
The choice: Claude Code Haiku. Anthropic's smallest model, but purpose-built for coding and tool use. Haiku is not the smartest agent in the fleet — it is the fastest and cheapest. For bounded tasks with clear instructions, it executes with high reliability.
The Matey was given a prompt:
You are Matey — worker subagent on Imperator.
Execute bounded tasks. Record results to Universalis.
Never delegate to other ships. Never claim objectives.
Only the Emperor closes objectives.
Simple rules. But they mattered. An AI worker that doesn't know its scope will expand its scope. An AI worker with explicit constraints will stay in its lane.
The first test: the General wrote a delegation node to Universalis, spawned the Matey with a task, and waited.
The Matey completed the task, wrote a result node, and returned.
The result had a parent_id pointing to the delegation.
The delegation had a parent_id pointing to the objective.
The graph was complete.
The first synapse had fired.
M6: Caravella — Windows Enters the Fleet
If Galleon was the fleet's GPU brain and Tanker would eventually be its logistics fortress, CaravellaDEFINITION // CARAVELLAThe Windows scout ship. Runs GitHub Copilot. A Windows Server 2025 vessel navigating the alien seas of Microsoft's ecosystem. Matey-powered, Claude Haiku as crew. was its strangest ship: a Windows Server 2025 machine navigating a fleet built primarily for Linux.
M6 established Caravella's captain scripts — the bootstrap sequence that would allow an AI agent running on Windows to participate in the fleet's protocol: write to Universalis, receive delegations, report results.
The challenge was significant. The fleet's tooling was Linux-native:
write_fleet_memory.pyrequired Python and PostgreSQL client libraries- SSH connectivity required careful key management
- PowerShell is not Bash
But Windows, for all its alien nature to the Linux-native fleet, represented a real capability: AI agents running in the Microsoft ecosystem, accessing Windows-native tools, operating in environments where Linux cannot easily go.
Caravella was not excluded because it was hard. It was integrated because it was hard — because a fleet that only works on Linux is not a fleet, it is a lab.
Caravella was integrated before there was a business case for it — because a fleet that only runs on Linux is a lab, not a fleet. The decision to absorb the Windows integration cost in M6 prevented a much larger forced-migration cost when Windows-native tasks arrived in M15+.
The deeper insight from M6 was about protocol universality. The fleet's coordination mechanism — write to Universalis, link parent_id, report result — did not inherently care about the OS underneath. PostgreSQL doesn't know or care whether the connection came from a Linux Python client or a Windows Python client. The network protocol is the same. The SQL is the same. The fleet memory schema is the same.
What M6 proved is that the fleet's protocol layer was genuinely portable. PowerShell could call Python. Python could call psycopg2. psycopg2 could write to PostgreSQL. The only work M6 actually required was the environmental setup — Python on Windows, the right database drivers, the right environment variables. The protocol needed no modification. That portability was a design dividend paid out by the decision in M1 to use standard, boring, well-supported technology.
What M6 Actually Built
# The first Caravella fleet memory write
python write_fleet_memory.py `
--actor caravella `
--content "Caravella online. Captain scripts deployed. Ready for delegation." `
--memory_type observation `
--status completed
It was that simple. And that hard. Cross-platform, cross-OS, cross-architecture AI coordination, unified by a PostgreSQL database that didn't care what OS was writing to it.
What Era I Established
By M10, the fleet had:
| Capability | Status |
|---|---|
| Persistent memory | ✅ Universalis online |
| Multi-ship | ✅ Imperator + Galleon + Caravella |
| Delegation protocol | ✅ General → Matey → Universalis |
| Windows support | ✅ Caravella captain scripts |
| GPU inference | ✅ Galleon qwen2.5:14b |
| Fleet Visualizer | ✅ M7-M8 initial build |
| Graph memory | ✅ parent_id linkage established |
The fleet was not polished. It was not stable. Agents still drifted from their prompts. Missions got scope-creep. The Matey occasionally forgot to write its result node.
But the foundation was real. The hierarchy worked. The delegation protocol caught errors that would have been invisible without the graph. And every mistake, once recorded in Universalis, could be traced, analyzed, and corrected — not forgotten and repeated.
The delegation protocol is not bureaucracy — it is error recovery. When an agent produces a wrong result, the graph tells you exactly what instruction produced it, which objective it was supposed to serve, and what the agent understood about its task. Without the graph, you have a wrong output and no way to know why. With the graph, you have a diagnostic trail.
Why does the General never do field work? Because context is finite and expensive. Every ls output, every file read, every command result the General processes burns context tokens. When the General's context fills with execution details, it has less capacity for strategic reasoning — for noticing a task was wrong before it executed. The Matey's context fills with execution details. The General's context stays clear for command.
Build your delegation graph from day one. You will use it more than you expect.
The lesson worth keeping: Delegation is harder than capability. Spinning up a capable AI model takes an afternoon. Getting it to reliably hand off work to a subordinate agent, track that work through a provenance graph, and maintain strategic coherence across the handoff — that is the months-long engineering problem. Plan for delegation complexity early, because it touches every layer of the system.
Pattern: Hierarchy before capability — define the command structure and information flow before you expand the roster. Each new ship should slot into an existing protocol, not force a protocol redesign.
What we'd do differently: The Matey prompt was too freeform at first. "Execute bounded tasks" sounds clear, but it left too much room for scope creep when a task turned out to be more complex than expected. The Matey needs an explicit escalation protocol: if the task is larger than N steps, STOP and report back rather than expanding autonomously. We discovered this the hard way when a Matey interpreted "fix the config" as a license to refactor three files and restart services. A clearer bounded-task definition with explicit stop conditions would have caught this in M5.
If you're building this yourself:
- Define your delegation node schema before you spawn your first subagent. The
parent_idlink is not optional — orphan nodes in a provenance graph are worse than no provenance at all. - Make protocol compliance structural: embed the
parent_idUUID in the subagent's prompt template, not in a separate documentation file the agent may or may not read. - Add one ship at a time and fully validate its protocol compliance before adding the next. Fleet complexity compounds — a protocol gap on ship three becomes a debugging nightmare on ship six.
← The Cogitator Stirs — Birth of Universalis
In AIverse, there is only Knowledge.