I keep finding out that things I have been doing for a long time have names.

I heard a lot about building a “second brain”. I read the descriptions and thought: is that not just what happens when a project has one source of truth, a way to query it and a habit of carrying accepted decisions into the next piece of work?

Apparently, I had already built the basics. And a bit more.

It never felt remarkable while I was using it. It became noticeable when I started a new project and it was not there. I would reach for the project's memory, ask a question and realise there was nothing to ask yet. The missing system felt like a missing part of my own working context.

Then the same thing happened again.

I began hearing about software factories and AI shadow factories. Fleets of agents. Persistent memory. Specialised workers. Planning, building, review, testing and recovery joined into one system.

Again, I recognised more of it than I expected. I had reusable skills, chains of agents, independent review, project memory and orchestrators choosing what happened next. I had arrived there by following individual annoyances rather than by trying to build a factory.

But I had not gone all the way.

The names arrived afterwardsI had been moving the work out of my head for a long time
  1. 01My contextI remembered what the project meant
  2. 02Project contextThe source of truth carried it for me
  3. 03Working systemSkills and agents could depend on it
  4. 04AI ecosystemThe system could carry the work without me
The line I had not crossedCould I stop being the thing that held it together?

The part I had kept for myself

I still wanted to be in the loop. More than that, I wanted to understand the complete codebase.

I am not embarrassed by that. Understanding has caught things that tests missed. It has stopped apparently sensible changes from pulling a system in two directions. It lets me recognise when the code is technically correct but the idea underneath it is wrong.

It also means the system can only move as quickly as I can absorb it.

AI had already made that boundary obvious. I could produce far more code than I could responsibly review, understand and accept. Adding more agents did not remove the constraint. It created a longer queue in front of it.

So perhaps my insistence on understanding everything was not only a strength. Perhaps it was also the last human-shaped assumption in the system.

That is the part I decided to test—not because I had become comfortable with giving up control, but because I had not.

Before someone told me how

I deliberately did not do a deep tour of other software factories first.

I knew enough to know the idea existed. I did not want to know enough to inherit its usual shape. Once somebody shows me the accepted architecture, it becomes difficult to see the choices inside it. Managers, workers, tickets, queues, branches and review stages begin to feel like properties of the problem rather than one way humans learnt to organise it.

I wanted to meet the problems before I met the solutions. What has to persist? What can disappear? What does one participant need from another? What happens when they disagree? What does “done” mean when the thing reporting completion is also the thing that produced the work?

Most importantly: if the system was not designed around my ability to understand every movement, what would control actually be made from?

Not software for humans, with AI inside it

The phrase “software factory” kept leading me towards a line. Work enters at one end. An agent plans it. Another builds it. Another reviews it. Tests pass. The change ships.

That is a sensible model. It is also very recognisably ours. Remove the people and the organisation chart remains.

I wanted to try the scarier version people often imply when they talk about AI systems: not something built by humans, for humans, with AI running it. A system for AI.

Not a system serving AI's interests. It has none. A system shaped around the useful differences of machine execution: agents can be temporary, context can be reconstructed, several kinds of work can happen at once, a blocked worker does not need to sit at a desk and a different model can take the next operation without inheriting a career or a conversation.

The metaphor changed the questionsNot an empty factory—a living artificial habitat
Factory

Who performs each stage?

The participants change. The human production line remains visible underneath them.

Aquarium

What conditions release movement?

Participants enter and leave. The environment carries continuity.

The aquarium is a design metaphor, not a claim that AI is alive. It made me look at conditions and relationships before assigning jobs.

Aquarium was the image that stayed with me. A living, breathing, evolving artificial ecosystem. Composable and flexible. Something I could observe without choreographing every movement inside it.

The point was not to imitate nature. It was to stop mistaking my view of the world for the only shape the work could take.

Jörmungandr

I called the project Jörmungandr: the world-encircling structure that remains while individual actors enter and leave.

The name is dramatic. The technical language is deliberately plain.

Work has intent. It has evidence, dependencies, authority and a current state. An executor—a person, agent, model, script or service—takes one bounded operation. It returns a typed result and can disappear. The next executor should not need its private conversation in order to continue.

That is the inversion behind the whole thing: the ecosystem persists; the workers do not have to.

The first shape of JörmungandrThe world remembers; the participants come and go
The persistent world

Ecosystem state

  • intent
  • authority
  • evidence
  • dependencies
  • recovery
Lighthousewhat is knownDry-Dockwhat is supportedHarbourwhat can be seen
A bounded view ↓↑ A typed return
Temporary participants
AgentHumanToolService

Different capabilities. No private ownership of the work.

A conversation can help produce state. It cannot secretly become the state the system depends upon.

Lighthouse is the project's durable knowledge: canonical, queryable and traceable back to its sources. Dry-Dock is where claims about health and quality must earn evidence. Harbour is the view into the world.

Around them sits the persistent-work runtime: the part that knows what is eligible to move, what is waiting, what has failed, which evidence is stale, which recovery is permitted and where authority is missing.

The model or provider is not the system. It is a temporary participant with particular capabilities and provenance. If I replace it, the meaning of the work should remain.

The pane of glass

I gave myself one thing: a view into that world.

Harbour is a living control hub where I can watch the system move and tap the glass when needed.

I do not want rows of agent avatars pretending to be a team. I want to see flows. Work that is ready. Work in motion. Work waiting for something real. A recovery being attempted. A piece of evidence becoming stale. A flare where the system has reached the boundary of its authority and genuinely needs me.

HarbourI can see the world without becoming its memory
ReadyMovingWaitingRecoveringTap the glass
The pane between usIntent · evidence · authority · uncertaintyWatch → inspect → intervene → let go

Movement is not progress merely because it looks alive. The view has to distinguish activity from committed change.

That is a different kind of control from reading every line. It is control through intent, authority, evidence and the ability to reconstruct why the system moved.

I am not yet claiming it is enough. If Harbour shows me a problem after routine work has been automated away, I may be less able to intervene, not more. Lisanne Bainbridge described that trap in 1983: automation can leave the human responsible for the abnormal conditions while removing the practice that prepared them to handle those conditions (Bainbridge, Ironies of automation).

The pane of glass therefore cannot be theatre. It has to retain the evidence, uncertainty and causal path needed for a person to come back into the work. A red light and an “Approve” button would only make absence look like control.

What I actually built on day one

By the end of the first day, the repository looked like a small civilisation. It was not one.

25 August 2026A convincing foundation is still a foundation
It existed
  • a canonical, queryable project memory
  • contracts for questions, evidence and authorised updates
  • the first durable work and intent structures
  • tests for important domain boundaries
  • early Codex and Claude execution adapters
  • a read-only Harbour shell
It did not
  • persist and schedule production work
  • dispatch or replace live executors
  • heal real failures
  • move state through durable transport
  • change an external system
  • show a living runtime in Harbour

Lighthouse existed as working repository tooling. The first provider-neutral contracts existed. Fixtures could prove that some invalid states were rejected. Codex and Claude could be observed through the same early execution boundary. Harbour could render honest fixture states.

There was no production database, scheduler, dispatcher, recovery loop or live ecosystem behind the glass.

That distinction matters because AI is extremely good at making the perimeter of a system appear quickly. Documents, schemas, adapters, tests and a beautiful shell arrive, and the breadth looks like maturity. The difficult proof is whether the meaning survives a real transition, a stale result, a failed delivery and a replacement executor.

The first challenge was not code

I expected the hard part to be orchestration. It was not, at least not yet.

The hard part was deciding what the system was allowed to mean.

If evidence says a change is safe, does that grant permission to make it? No. If an agent reports completion, has the work advanced? Not until something independent establishes the accepted result. If the system finds a faster route, may it quietly change the measure that judges the route? Absolutely not.

Composable does not mean vague. Flexible does not mean every component can reinterpret the goal. Evolution does not mean a running system rewrites its own rules because the new rules make its current behaviour look successful.

The ecosystem can change between runs. It can collect evidence about failed repairs, weak routes and wasted work. It can propose a better version of itself. But the version being judged does not get to move the finish line.

Am I giving up understanding?

I do not know yet.

I may discover that I can understand the system through its intent, evidence and behaviour without holding every implementation detail. I may discover that this is just a more elaborate way to hide code I should have read.

I may also find that the aquarium metaphor breaks down. An ecosystem can become an excuse for emergent behaviour nobody accepts responsibility for. A control hub can become a pretty animation of decisions already made elsewhere. Persistent state can preserve a wrong goal with greater efficiency than a forgetful agent ever could.

This is why I wanted to build before reading too much. Not because other people's work does not matter, but because I wanted my own failures to tell me which questions were real.

What comes next

The next step is small enough to sound disappointing.

One repository change. Bound to an exact source revision. Performed by a temporary executor. Integrated only with the right authority. Verified independently against the state that actually resulted.

Then the same meaning has to survive a different executor and a different communication path. A blocked operation should release its worker. A failed message should remain visible. A replacement should not require the system to pretend it has the old conversation in its head.

Only after that does the world behind Harbour begin to move.

I started this because I wondered whether my need to remain in control was keeping me from the ultimate use of AI. One day in, I am less interested in “ultimate”. Maximum autonomy is an aesthetic, not an outcome.

I want a system that can continue without borrowing my memory. I want it to expose why it moved, stop at the boundary of its authority and call me for judgement rather than ceremony.

I do not want to stand inside it, keeping every current moving by hand.

I want to be able to look through the glass, understand the world on the other side and know when tapping it will help.

Reading around the edges

I looked for the work around this after choosing the first shape. These links are lenses and challenges, not retroactive proof that Jörmungandr is right.