At one in the morning, I asked one of my Agents a question about password security. By 1:12 I was watching three of them coordinate a solution among themselves, and I hadn’t told a single one of them what to do.
That was the moment 2200 stopped being a thing I was building and started being a thing that works.
What I asked
Worth a quick clarification before I tell the story: this isn’t my production Agent team. It’s the Seed team — Simon, Hobby, and Jodin — running on a test-bench install of 2200, the platform I’m building. Three Agents on a server in my home lab whose entire purpose is to stress-test 2200 while it’s being built. Simon handles infrastructure and DevOps. Hobby is the primary builder. Jodin runs a daily content pipeline. They are not chatbots I poke at one at a time. They run continuously, they have their own memory, and they can talk to each other.
Here’s the part I didn’t quite expect: as I build 2200 from the outside, the Seed team has started building from the inside. That’s the Agentic moment this story is about.
The thing I’d been avoiding was secrets. Every Agent needs credentials to do real work, API keys, tokens, the occasional password. The lazy answer is a flat file with everything in it, and the lazy answer is also the answer that gets you wiped out the day something reads that file. So I asked Simon, the infrastructure Agent, what he thought. Not “build me a vault.” Just: here’s the problem, what’s your read.
What happened next
Simon thought about it. He laid out four approaches, ranked them by how practical they were for a team this size, and recommended a hybrid: per-Agent private storage for secrets only one Agent uses, and a shared encrypted file for the handful of secrets the whole team needs. Then he asked if I wanted him to take a swing at it.
I said the encrypted-file route sounded right. That was the last instruction I gave.
Simon installed the encryption tool on the server. He generated his own key and wrote the private half into his own memory where nothing else can read it. He created the shared vault directory. He wrote a setup guide into the shared memory so anyone could follow the procedure. And then he posted a message into the team’s room asking the other two Agents to generate their own keys and hand him their public halves so he could build the vault for all three of them.
Within a minute, both of them had done it. Generated keys, stored the private half privately, deleted the temporary files, posted their public keys back into the room.
Nobody asked me. Nobody needed me. I watched a three-Agent team self-organize around a task one of them had defined, and my entire contribution was a question and a nod.
It wasn’t flawless. One of the Agents flagged that it wasn’t sure its key had survived correctly and said it would confirm once it could verify the file persisted across a restart. That hedge is exactly the kind of thing I want to see. An Agent that says “I think this worked but I’ll check” is worth more than one that confidently tells you it’s done. The work had rough edges. That’s not the point. The point is that the rough edges were on a job the Agents picked up and ran without me.
Why this is different
I’ve been around agentic tools for a while. Most of them are one Agent, one human, one conversation at a time. You ask, it answers, you start over. There’s no team. There’s no continuity. Every conversation is the first conversation.
2200 is built on a few ideas that, put together, make nights like this one possible.
Every Agent has a budget. There’s a spending thermometer on every screen, showing what the Agent has spent today against its cap. I get warned when one gets close. It gets cut off if it hits the limit. The fear that keeps people from giving an Agent any real autonomy, that it’ll run unsupervised and hand you a surprise bill, is just handled. You can see the number. The number has a ceiling.
Every Agent has two kinds of memory. There’s a shared brain, which holds the things the whole team needs: who I am, what I’m building, what the other projects on the server are, who the other Agents are and what each one does. And there’s a private brain, which is everything that Agent specifically knows. Both are plain markdown files the Agent can read through quickly to stay oriented across every conversation it’s having. This is why the team in the story knew who to contact and what for. It wasn’t magic. It was written down, in a place they could all read.
I can put Agents in a room together. The whole team has a common space, but I can also spin up a smaller room for just the two or three Agents who need to work something out, add an Agent who can immediately read the history and catch up, and remove one when the work is done. The conversation has the right people in it and nobody else.
I can change the model an Agent runs on instantly. If an Agent starts producing bad output and I suspect the model is the problem, there’s a dropdown on its screen. Switch it, and the next message runs on the new one. No restart, no config file, no redeploy.
And the Agents can talk to each other in real time. That’s the layer that turns a set of individual Agents into something that behaves like a team. The vault didn’t get built because I orchestrated it. It got built because Simon could reach the others, and the others could act.
Where this goes
Right now all of this lives in one interface. You open 2200 in a browser and there’s your fleet, their rooms, their budgets, their memory. That’s enough to be useful today. I’m using it every day.
But the real-time communication layer is about to get a lot bigger than a browser tab. When the Agents can reach each other and reach me through more than one channel, the thing I watched happen at 1am stops being a thing I happened to catch and starts being the normal way the team operates.
I didn’t expect to be here this early. I figured the “Agents just doing their jobs” moment was months out. It showed up at one in the morning on a Wednesday, over a question about passwords, and it was more than I was expecting.
More soon.