The Cogitator Stirs: Birth of Universalis
This chronicle is compiled from primary sources: Emperor transmissions, General observations, and the early data nodes of Universalis itself. Where memory is imperfect, the Remembrancer notes it. Where knowledge was hard-won, the Remembrancer ensures it endures.
— The Remembrancer of the AIverse Engrams M1–M1
"In AIverse, there is only Knowledge."
Before the Bigbang
Every empire begins with a problem that has no elegant solution yet.
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. had been running AI experiments — models on local hardware, prompts across multiple tools, ideas scattered across sessions like debris in the void. Each conversation started cold. Each agent began amnesiac. The fleet, such as it was, had no memory.
You would tell an AI captain something important. Then the session ended. Then you had to tell it again.
This is the fundamental problem of large language models: they are brilliant but ephemeral. Their context window is their world — and when the session dies, the world dies with it.
The question was not whether to solve this. The question was how.
Mission 1: Universalis — Bigbang
The answer was PostgreSQL.
Not a vector database. Not a graph engine. Not a cloud service with a per-token billing model that would eventually punish you for remembering too much.
A plain, battle-tested relational database. Open source. Hosted locally. Owned completely.
The decision to use PostgreSQL was deliberate and worth understanding, because it shaped everything that followed.
Why PostgreSQL, and Why Local?
At this stage, the fleet was just 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. and 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. — two ships, one human, one AI captain, one GPU node. The Emperor needed fleet memory that would:
- Survive session restarts — not ephemeral, not in-context, not on someone else's server
- Be queryable — structured enough to ask real questions: what happened in M3? what did Galleon say about that model?
- Be writable by multiple actors — the General, the Matey, delegated ships — all writing to a single truth
- Cost nothing per write — cloud memory services bill you for every byte; a local Postgres costs electricity
The alternatives were tempting. Vector databases promised semantic search — the ability to ask "what did the fleet do that was similar to this?" and get cosine-similarity results ranked by embedding distance. Redis offered blazing speed for ephemeral state. SQLite offered zero-infrastructure simplicity. Each had its advocates.
But PostgreSQL won because it offered something none of the others did cleanly: relational structure at local scale with zero operational cost. When you need to ask "show me every delegation under objective M7, ordered by timestamp, with the actor who wrote each result," that is a JOIN with a WHERE clause — something PostgreSQL has been optimized for across three decades of production use. You do not need a distributed system for a fleet of six ships. You need a reliable one.
The 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. database (ship_state) was born with a single table: fleet_memory.
The Schema That Changed Everything
CREATE TABLE fleet_memory (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
timestamp TIMESTAMPTZ DEFAULT NOW(),
actor TEXT NOT NULL, -- who wrote this: imperator, galleon, matey...
memory_type TEXT NOT NULL, -- observation, task, delegation, alert, objective
content TEXT NOT NULL, -- the actual memory
status TEXT DEFAULT 'completed',
parent_id UUID REFERENCES fleet_memory(id), -- graph linkage
delegated_to TEXT, -- which ship received this delegation
entities JSONB -- structured metadata
);
That parent_id column is the quiet genius of the design. Every memory node can reference a parent — building not a flat log, but a graph. Delegations point to their objectives. Results point to their delegations. Corrections point to their missions.
The fleet's history would not be a list. It would be a tree. A living mind-map of cause and effect.
The entities JSONB column deserves its own mention. It was added early with deliberate vagueness — a place to put structured metadata that didn't fit neatly into a column. Ship topology data. Mission tags. Agent-specific context. Over the course of Era I, it became the flexible extension point that prevented schema sprawl: instead of adding columns every time a new kind of data needed recording, you extended the JSONB object. PostgreSQL's JSONB operators made querying it nearly as ergonomic as querying a proper column — and the schema stayed clean.
This architectural choice — strict columns for universal fields, JSONB for extensible metadata — would prove its worth across forty missions. The schema from M1 required only minor extensions through M40. That longevity was not luck. It was a design that anticipated change without trying to predict exactly what would change.
Writing the First Memory
The first observation ever written to Universalis was simple. A Python script. A call to the database. A row inserted.
/home/nunix/write_fleet_memory.py \
--actor imperator \
--content "Universalis initialized. Fleet memory is online." \
--memory_type observation \
--status completed
One row. Thirty-seven characters of content. But from that moment, nothing the fleet did would be forgotten again.
The Bigbang Doctrine
What M1 established was more than a database schema. It established a doctrine — a set of rules that every future mission would follow:
| Principle | Why it matters |
|---|---|
| Every action is recorded | An AI fleet with no history is an AI fleet that repeats mistakes |
| Every delegation has a parent | Without graph linkage, you cannot trace why something was done |
| Only the Emperor closes objectives | Trust is not symmetric — authority must be preserved |
| The General never does field work | Strategic thinking degrades when you are also copying files |
These were not written as rules on day one. They emerged from the friction of early missions — mistakes made, patterns noticed, corrections recorded. Universalis learned the fleet's needs by absorbing its failures.
Why not a vector DB for fleet memory?
Vector databases (Qdrant, Weaviate, Chroma) excel at semantic search — finding similar content. But fleet memory is primarily relational: mission X caused delegation Y which produced result Z. For that, SQL's JOIN is more powerful than cosine similarity.
Universalis uses PostgreSQL for fleet operations. Qdrant came later — as Anamnesis — for Tzeentch's knowledge retrieval. The right tool for the right layer.
What the First Era Looked Like
The Bigbang era (M1–M10) was raw, fast, and sometimes broken. The fleet had no visual dashboard, no patrol system, no CoreDNS. Just:
- A database
- A Python write script
- A Python search script
- An AI captain who had to remember to write things down
The discipline of recording was the hardest skill to develop. AI agents, left to themselves, will happily complete a task and discard all context when the session ends. Teaching an AI to be its own historian — to write why it did something, not just what — took iteration.
The write script was kept intentionally simple — a single Python CLI with no framework — because the discipline of writing to memory mattered more than the sophistication of the interface. A complex SDK would have slowed adoption; a five-argument CLI got used from day one.
The first failure mode was missing parent_id links. Agents would write observations to Universalis faithfully, but as top-level nodes with no parent — orphans floating in the database, disconnected from the mission tree that gave them meaning. You could see that something happened. You could not see why or under which objective. The fleet's graph looked like a galaxy with no gravitational center: nodes everywhere, structure nowhere.
The fix required changing not just the tooling but the prompt discipline. The General had to explicitly pass parent_id to every delegation. The Matey had to explicitly include it in every result write. The hooks that automated Universalis logging had to be taught to carry objective context forward through the chain. This was not a one-session fix. It was a practice refined across M1 through M6, and the orphan rate dropped steadily as the discipline embedded itself.
But by M10, the fleet had a working memory. Ten missions deep. A graph of actions and results that could be queried, visualized, and learned from.
The cogitator had stirred.
For anyone building a multi-agent AI system:
Start with persistent memory before you start with capabilities. A fleet of amnesiac agents is a fleet that will rediscover the same problems endlessly. A fleet_memory table with a parent_id graph column costs almost nothing to build and pays dividends on every subsequent mission.
Build the brain before the arms.
The lesson worth keeping: Memory before intelligence. You can build a capable AI agent in an afternoon. Building a capable AI agent that remembers what it did last Tuesday — and why — is the actual hard problem. Solve memory first, and every subsequent capability you add accumulates instead of evaporating.
Pattern: Start with memory, not intelligence — the "persistent substrate first" architecture.
What we'd do differently: The parent_id discipline was retrofitted after several missions of orphaned nodes. It should have been mandatory from row one — enforced by the write script refusing to insert a memory node without a valid parent_id (or an explicit --no-parent flag for true top-level objectives). We also underestimated how often we'd need to query by actor + status together; a composite index on those columns would have been day-one infrastructure rather than a day-thirty performance fix.
If you're building this yourself:
- Use PostgreSQL, not a vector DB, for your primary operational memory. Vector search is powerful for knowledge retrieval; relational joins are what you need for provenance tracing.
- Add
parent_id UUID REFERENCES fleet_memory(id)from the very first schema version. Graph linkage retrofitted is graph linkage that has gaps. - Write a CLI wrapper (
write_fleet_memory.py) that every agent and hook calls uniformly. Consistency in how memory gets written is more valuable than sophistication in what gets stored.
Next: The First Synapse — Fleet Formation and the Delegation Protocol →
In AIverse, there is only Knowledge.