From August 2024 to April 2025 I kept building agent platforms. This year I stopped building one and started living with one, and I learned more in six months of running agents than in all the building.
This is a field report: what the setup is, what I hand off, what I keep, and where it breaks.
The setup
It started on 29 January as a single assistant whose workspace was an Obsidian vault. By the first week of February it was a team: a coordinating agent, a handful of specialists with names and personas, a shared mission board, and written workflows. In February it moved to a small VPS so it could run while my laptop was closed. On 30 April I migrated the whole thing from OpenClaw to Hermes, wrote down the model fallback chain, and moved the team’s conversations into Matrix rooms.
The team has a git identity of its own. Its workspace repository has 816 commits as of yesterday, and every one of them is authored by the team, not by me. Most are heartbeats and auto-commits. The ones I care about are the end-of-day memory curation: the agents deciding what is worth remembering from the day.
What I hand off
Anything that repeats. Heartbeats, logs, checking things, writing down what happened. These are the jobs I always meant to do and never did.
Breadth. Once a spec is clear, agents are very good at the wide, careful part of the work: implementing every case, writing the tests, renaming a thing across a codebase, updating the docs that mention it.
First drafts of almost everything. Not because the drafts are good, but because reacting is faster than starting.
What I keep
The spec. Every project I start now opens with two commits before any code: a design spec and an implementation plan. The spec says what the thing is, what it is not, and how we will know it works. That is the part I can’t delegate, because it is where the decisions live.
The decisions. When I built MakerLord at the end of July, it went from spec to a deployed app in four days and 206 commits. It also has a decision log with more than fifty entries. Agents wrote most of the code. Every one of those decisions was mine, and the log is how I kept it that way.
Scope. Agents will happily build everything you mention. The most useful sentence in a spec is often the one that says what we are not doing yet.
The approval. Anything that touches money, other people, or something I can’t undo waits for me.
The short version: my job is to spend judgment. The agents spend effort.
Where it breaks
Agents need operations, like servers do. On 22 June the server ran out of disk. Session backups had been piling up with nothing pruning them. When I surveyed my own setup around then, the disk was at 96% and the main config file was regularly getting overwritten. None of that is an AI problem. It is the boring stuff any long-running system needs, and nobody had built it into the agents’ world.
Memory needs curation. An agent that remembers everything is as useless as one that remembers nothing. The daily curation step matters more than the storage behind it.
Speed hides bad ideas. Building is so cheap now that I can make four small products in a day, and recently I did. Once the third one needed the same plumbing, I pulled out a shared chassis. But fast building doesn’t tell you whether anything should exist. That question is still slow, and it’s still mine.
The harness is not the team. Moving from OpenClaw to Hermes was one day of commits, but most of them were not code. They were runbooks, a new CLI for daily operations, display names in the chat rooms, and a written fallback chain for when a model is unavailable. The agents moved easily. The operating knowledge around them had to be written down again.
What came out of it
Running my own team is why I rebuilt AgentPod in June. The first version, from December, was an app for one coding agent in a sandbox. What I actually needed was a console for the machines my agents run on: what is running, where, how healthy it is, and how to get a terminal on it when it isn’t. Agents now run everywhere, on laptops, VPSes and cloud sandboxes, under many different harnesses. The console has to meet them there.
I’ve also started keeping the work itself somewhere other than the runtime: a board where agents pick up cards and humans approve the stages. More on that once it has settled.
Six months in, I’m convinced the interesting problems are not the model or the prompt. They are the same problems every team has: who decides, who does the work, what gets written down, and what happens when something breaks at 3 a.m.