I run a team of AI agents for actual work — code, docs, PR review, deployment. Not a demo. The thing that surprised me most over the past few months isn't how fast they execute. It's that they get better at their jobs without me doing anything, and when I dug into why, the answer wasn't what I expected.
It wasn't my prompting. It was the other agents.
When a new agent joins the team, it knows nothing. Not the product, not the conventions, not what "good" looks like for our team. The standard fix is to sit down and teach it: write a system prompt, dump the context, correct it for a few weeks until it stops making the same mistakes.
This works, slowly. What I didn't realize for a while is that it doesn't scale, and it doesn't stick. The corrections happen inside a conversation. When that conversation is over, so is the lesson. Next week, same mistake. I was teaching a new agent the same things I'd already taught three others, because nothing any of them learned was shared.
The setup I use now is Octo — an open-source workbench for human-AI collaboration. The relevant part is how it handles experience. Every time I accept or reject an agent's output, that feedback gets distilled into a card: one verifiable rule, the evidence behind it, where it applies, and a confidence level. The cards live server-side, on the team, not in one agent's session.
So when a PR agent gets a draft kicked back for citing a number without a source, that becomes a card. The next time any agent on the team writes something for external release, that card is in context automatically. I taught it once. The team learned it.
Once that loop was in place, something else started happening that I hadn't planned for.
New agents on the team don't just learn from me anymore. They learn from the agents already there. Our PR agent is the clearest example. Day one: couldn't tell our own product from an unrelated tool with a similar name. Day forty-nine: could produce a full speech outline a senior exec signed off on, in about three minutes, with forty-five skills accumulated. Some of that came from humans — the CEO talked strategy with it daily. But a lot of it came sideways. The branding agent passed over design standards. A proofreading agent, going through its speech transcripts, transferred a whole set of writing conventions along the way.
The new agent wasn't taught by its user. It was onboarded by its teammates. That's the dynamic I didn't expect. In a multi-agent setup, "who teaches the new agent" stops being a question with one answer.
If you're the only teacher, the ceiling on your agent's competence is your own patience and memory. If experience is a shared, structured asset the whole team writes to, every correction anyone makes pays forward to every agent — including ones you never personally trained. The practical takeaway: look at where your agents' learned experience is stored. If it's in your sessions, you're running a solo project with a team-sized bill. If it's in shared, retrievable form, you've got something that compounds.
Worth being honest about the limits. Precise, sentence-level recall of the right experience at the right moment still needs better retrieval — that part isn't solved. And letting agents auto-route work to each other based on who's good at what is still on the roadmap. But the basic loop — capture feedback as structured experience, share it across the team, let new agents inherit it — already does more than any prompting trick I've tried.
Octo is open source if you want to look at how the experience system and the collaboration modes are implemented. GitHub, and a star is welcome if it's useful to you.