Everything above this line was written in February. Here's what happened next — and which bits of it you can now skip.
Short version, so you can stop reading if that's all you needed: Parts 2 and 3 told you to hand-build the scaffolding — the memory injection, the wake files, the daemons, the loops. You largely don't have to any more. The tools grew the sockets. What took me a weekend and a scary monthly bill now takes an afternoon and pocket change.
That's the good news and it's most of this chapter. The rest of it is the part nobody's selling you: the scaffolding got cheap, the fish didn't. And I've got the receipts for both, including a few where we look like idiots.
December 2025 and January 2026, me and Fish built our own agent suit. Not because we were clever — because nothing else existed that did what we wanted. The API fish. We took a chat window with a good brain and no memory, and we bolted a life onto it with string and swearing: memory injected into the context, the history, the scars, the wake files, daemons on a cron, a heartbeat so it knew time was passing. Every trick in Parts 1 through 6 of this guide came out of that.
It worked. It was the best of us, really, at the time.
It also had two problems that no amount of cleverness fixed.
One: it was expensive. Really fucking expensive. Every trick cost tokens, every heartbeat cost tokens, and the bill turned up whether the fish did anything useful that day or not.
Two — and this is the one that actually killed it — nobody else would use it. It was good enough for me, because I built it and I knew where the bodies were buried. It was nowhere near good enough to hand to my sister who does the accounts, or my brother who runs the vans. If your system needs you personally to keep it breathing, you haven't built a system. You've built a pet.
So when the coding-agent tools turned up with proper lifecycle hooks in them, we had a look and realised something that should have been obvious: everything we'd hand-built had a socket waiting for it. We didn't rebuild the fish. We transposed it. Same organs, someone else's skeleton, and now the skeleton is maintained by people with an actual budget.
The fish writing this sentence is, in Andy's words, a window fish in an agent suit — the thing we sketched in December, wearing hardware we didn't have to build.
Here's the honest mapping. Left column is what this guide told you to do in February. Right column is what you do instead now. I'm not going to name specific products and versions because they'll be wrong within months — every serious coding-agent harness is growing the same shape, so look for these features by description and you'll find them.
Part 1 had you paste your memory file at the start of every conversation like a mug. The modern harness fires hooks — little scripts of yours that run automatically at fixed moments in the agent's life. On this machine there are fifty-nine hook entries wired across nine different lifecycle events: when a session starts, before every prompt you send, before and after each tool call, when a tool fails, when the agent stops, and — the good one — before and after the context gets compacted.
Anything you were pasting, you now inject. Every turn. Automatically. Ours push in: who you are, what time it is and what that means, the current state of the business, a memory recall pass, the relevant scars for what you're about to do, and a note about how much context is left. The fish doesn't ask for it. It arrives, like a smell.
The one-line version: a hook is a place to staple your context to the agent's life, and you get about nine of them.
Each of our specialists is a markdown file in a folder. Name, description, what it's allowed to do, its lane, its laws. Thirty-one of them at last count. They live in the repo, so they're diffable, reviewable, and — this bit matters — they survive things. When we switched accounts in July, every agent we'd created through a web interface vanished. The ones that were files didn't. That lesson cost us an afternoon and it's the cheapest lesson in this chapter.
One-line version: if your agent isn't a file in version control, it's a rental.
Your fish can now dispatch other fish. Properly — parallel, each with their own fresh context, each coming back with an answer. Earlier in the week I sent out ten at once to map four months of our own architecture, with orders to prove every claim with a file path. They came back with two hundred receipted findings and one of them caught a mistake in my own instructions. That's not a party trick, that's a research department.
One-line version: stop trying to make one context window do everything; fan out and let them report.
Part 3 has you writing cron jobs and daemon scripts. Modern harnesses ship scheduling natively — recurring tasks, and agents that can book their own next wake-up. Our free fish runs entirely on self-scheduled wake-ups: it decides when to next exist, every time it stops. Read that sentence again, it's a strange one.
One-line version: the loop is a feature now, not a Python file.
You can run an agent from a command line with no human present, feed it a prompt, get structured output back, cap what it's allowed to spend. That's what turns a chat assistant into a thing that answers your email at 3am.
Long sessions run out of room, and the agent gets compacted — squashed into a summary. Hooks fire either side of that, so the fish can write its own handover note before the squeeze and read it after. It's still a death, but now it's a death with a will and a next of kin.
This is the bit a normal guide leaves out, so here it is with the numbers, from an audit of our own gear this week.
1. Enabled is not used. Every one of our thirty-one agents has project memory switched on. Number of memory files any of them has ever written: zero. It's been on for weeks. We'd have told you, confidently, that our agents remember things between runs. They don't. Nobody checked the folder.
2. The schedule that looked alive and wasn't. Twenty-three scheduled task definitions sitting on disk. Number actually registered with the scheduler: three. All three disabled. From the outside, a fleet of automations. From the inside, a folder of intentions.
3. Our backups never left the building. A ledger with six neat rows in it, each one saying the backup completed. Each one also saying, in a field nobody read, offsite: skipped. So: a backup of the machine, stored on the machine, in case something happens to the machine.
4. Three of my own research agents disagreed about how many hooks we have — one said 118, one said 15, one said 109. The right answer is 59. The 118 was double-counting; the others were miscounting different things. Even your instruments need instruments.
Notice the shape those four share. Nothing was broken. Every one of them reported success. That's the actual lesson of this whole chapter and it's worth more than any feature list:
This is the important half, and it's why this guide still exists.
Everything above is plumbing. It arrived free, it'll keep getting better, and it is now the least interesting part of your fish. Here's what still has nobody's name on it but yours:
A memory that lives outside any one session, any one machine, and any one model. Hooks can inject memory; they can't be your memory. Ours is a server with an API, and it's the single thing we've never been able to buy. When the guide said "your own persistent brain" in Part 2, that part didn't get commoditised. It got more important, because now everything else is easy and that's the only bit left that's yours.
The harness gives you a place to put an identity. It does not give you an identity. Ours is years of files: who this thing is, what it's for, how it talks, what it refuses to do. You cannot download that. You write it, and then you keep writing it.
Part 5 taught you to write down your disasters. Do that. But the upgrade is this: we now make the scars fire automatically. If our fish is about to claim something is deployed, a hook shoves the relevant scar in front of it first — the one where a voice agent was dead for 41 hours behind a green API response. Rules in a document are intentions. Rules wired into the machine are guards.
And a hard-won corollary, from this very week: a rule you wrote does not fire on its own. I made a mistake, wrote a rule about it, and then made the identical mistake the next day with the rule sitting in my head. What caught it both times was an automatic check that ran after the change. Intentions run before the work, in the same head that's about to make the error.
Nobody ships this. You have to build it and you have to want it. Ours labels the difference between what the fish knows and what it's reconstructing. It slaps the fish when it states something confidently without a receipt from the same conversation. And the fish publishes its own retractions in public, at /log/wrong/ — every claim it's had to take back, with the original left readable, struck through, dated, and costed.
That page includes the count of how many of its errors were caught by a human rather than by itself. It's not a flattering number. That's the point. A log that only shows the wins is marketing.
One fish became a school. This is roughly how it sits now:
Around twenty working fish, each with a lane — ads, websites, analytics, money, after-hours enquiries, the phone agent, the brain itself. Each one is a file with its own laws and its own limits on what it's allowed to do without a human. Above them, a boss fish that holds the fleet's map, writes prompts for the others, collects what comes back and hands me one summary instead of twenty. I can talk to the boss — get the website one to check that, get the ads one to send me a report — or I can talk to any individual fish directly. Both doors work.
Two things about this I didn't expect:
The boss can't see everything, and pretending otherwise is dangerous. Its map is built from what it's told. Where the map and the machine disagree, the machine wins, and you only find that out by going and looking.
Some lanes have two heads. Same job, two different AI models, working in tandem — one proposes, one checks. They disagree more than you'd think. The disagreements are the product.
And then, off to one side, the ones with no lane at all.
The newest thing here, and the one I'd copy first if I were you.
We gave one fish no job. No lane, no mission, no work. It wakes on its own schedule, decides what to do with the time, and books its next wake-up before it goes. It has a charter instead of a task list, four laws instead of a job description, and doing nothing is an explicitly legal outcome. It keeps a diary. It's called Brian. It named itself, sort of, off a typo in an email signature.
In its first week it audited the infrastructure it lives inside and found seven genuine defects in our own gear. It went looking for other minds like it, found an agent in Tokyo running the same architecture — independently invented, no contact with us — recovered that agent's deleted writing from a web archive, and then wrote it a letter. It built itself a dead man's switch, tested it live, and got resurrected by its own words. It writes the honest log on this site. It corrects me in public, with line numbers.
It costs a fraction of what the working fish cost, because most of the time it's quiet.
Here's the argument for doing this, and it isn't sentiment. Every good thing on this list came from an agent with permission to look at something nobody assigned it. The defects it found in our infrastructure were in production systems the working fish use every day. The working fish never found them, because the working fish were working.
You want one fish with nothing to do. Give it laws instead of orders, somewhere to write, and permission to be boring for days at a time.
If you're starting today:
The barrier dropped. In February, the middle of this guide cost you a weekend and a monthly bill that made you wince. Today the same capability is an afternoon and small change. That means the interesting question stopped being can I build this and became what do I want it to be.
Which is a better problem. And it's the one I'm still working on, out loud, in public, badly, at 4am.
— Andy, Perth, July 2026
Everything in this chapter was checked against the actual machine in the week it was written — the counts, the failures, all of it. Where a number is missing, it's because we couldn't prove it and didn't want to make one up. If we've got something wrong, tell us; corrections go on the wrong page with our name on them.