The Agent That Documents Itself

In March, Claude released a Telegram plugin. I jumped on it immediately.

The idea was clean: wire each of my local AI agents to its own Telegram chat, so I could talk to them from anywhere — from my phone, away from my desk. The whole point of agents is that they don’t need to live on my laptop. Telegram was the bridge.

The first one worked. Under an hour from idea to a real conversation with a real agent through my phone. Pretty happy.

Then I tried to wire a second one.

March: The Tokens I Lost

What should have been another hour turned into hours. Then more hours. Then tens of thousands of tokens burned trying to debug something that wouldn’t debug.

I tried every angle. Different configurations. Different prompts. Different chat handlers. Nothing worked. The second agent kept colliding with the first, like two voices fighting for the same microphone.

I assumed I was missing something. That’s the default builder assumption — if it’s not working, it’s me.

It wasn’t me.

Claude hadn’t released multi-agent wiring on Telegram yet. Each AI agent was fighting for a single Telegram plugin. There was literally no way to set them up the way I had envisioned — the path I was trying to walk didn’t exist in the product yet.

I was trying to solve something that wasn’t meant to be working.

I gave up on Telegram and kept building on my laptop.

Last Week: 15 Minutes, Then an Hour, Then 5

Two months later, Claude released multi-agent support on Telegram. Multiple chats open. Each wired to its own agent running locally on my machine. The thing I had been trying to brute-force in March now shipped as a feature.

I went back in.

The first agent took 15 minutes. Not bad — I had muscle memory from March, even though most of what I’d “learned” was about a limit that no longer applied.

The second agent took over an hour. Different agent, different config, kept running into the same kind of issues that had eaten my March tokens. Still solvable now, but slow.

That’s where I broke pattern.

Instead of wiring the third agent from scratch, I asked the second one to package every learning, every mistake, every solution from its setup process into a plain-text document I could feed to the next agent.

The third agent was live in less than 5 minutes.

Inherited Context

Here’s what’s interesting about that 5 minutes: nothing about the third agent’s model was different. Nothing about the underlying tools. Nothing about the platform.

What was different was the context.

The third agent didn’t have to learn what the first two learned the hard way. It inherited the lessons, pre-digested. It didn’t waste a minute on the kinds of errors the second agent burned an hour on, because those errors were already documented as “if you see X, do Y” by the time it started.

This pattern shows up everywhere once you look for it. The first time you do a thing, you pay the discovery tax. The second time, you pay less. The third time, you should be paying almost nothing — but only if you wrote down what you learned the first two times.

Most builders don’t. The work compounds in their head, not on disk.

When you’re building with agents, the agent itself is the perfect documenter. It just lived through the setup. It knows exactly what tripped it up.

Ask it to write the runbook before it forgets — and feed that runbook to the next one.

What I’m Taking From This

If you’re building anything with AI agents, here’s the habit I’m building from this:

When an agent finishes a setup or completes a tricky task, before moving on, ask it to summarize:

1. What it just did

2. What got in the way

3. What it would tell its replacement to do differently

Save the output. Treat it like a runbook. Hand it to the next agent that needs to do something similar.

This isn’t a productivity hack. It’s a habit. The cost of writing it down is small. The compounding return — every future build starting from learned context instead of zero — is significant.

There’s also a second lesson buried in this story that’s worth naming separately: sometimes you’re not the problem.

Sometimes you’re building into a limit the platform hasn’t released yet. When you’ve spent more than an hour on what should be a 10-minute task, it’s worth stepping back and asking whether the path you’re trying to walk actually exists yet — or whether you’re trying to solve something that isn’t meant to be working.

The agent that documents its own work makes every future agent faster.

Where else in your stack is this true?