Recursive Self Improvement for AI Agents

Recursive self-improvement is the process of building AI agents that learn from their own output and get smarter every time they complete a task. Anthropic recently shared that they’re generating eight times more code than they were just a few quarters ago using this same approach. The principle is straightforward: when an agent does work, it documents what it did, learns from the result, and uses that knowledge to perform better next time.

The real power here isn’t just efficiency. It’s that you’re building a compounding competitive advantage. As your agents improve, the gap between what you can deliver and what a competitor starting from scratch can deliver grows wider every day.

Start with prototyping

Before you try to automate anything at scale, you need to prototype. I see too many people jumping straight into persistent cloud-based agents without having done the groundwork, and it creates a mess.

Start in the browser. Use Claude in Chrome, the Atlas agent, or Perplexity’s Comet. You’re already logged into your tools, so the assistant can sit alongside you as you work. Whether you’re inside WordPress writing articles or inside your CRM managing leads, the agent watches and learns.

You can record your screen and let the agent observe how you complete a task, or you can feed it your Zoom call transcripts. Either way, the agent is building what we call a skill file. A skill.md file captures exactly how a particular task gets done.

Build your skill files

A skill file lives inside what we call a definitive article. A definitive article says, “This is how you get this task done.” It’s the complete reference for a specific workflow.

Here’s the key: you need to demonstrate a task at least three times before you consider it ready to scale. Each repetition helps you catch edge cases and refine the inputs. After three cycles, you have a solid understanding of what the agent needs to succeed.

Take our agent Jennifer, for example. Jennifer grades articles. Her body of knowledge gets smarter over time because she has access to a growing repository of rules, reference content, and external tools like Ahrefs.

Every time she completes a task, she also writes what we call a meta article, documenting what she did, what it cost in tokens, and what the outcome was.

Treat agents like people

This might sound unusual, but you should treat your agents like employees, not software. Name them after the people who originally did the work. Pay them per task. Monitor their output. Onboard them gradually as they prove themselves.

We have Jennifer for article grading, Ethan for knowledge panels, and Cam for collecting positive comments. Each one has a specific job, a skill file, and a growing track record. When one agent finishes its work, it can trigger the next agent in the chain, just like handing off tasks between team members.

Move to persistence

Once your agents are tested and tuned, you move them from browser-based prototyping to persistent systems. This means they can run on your computer continuously without dying when the browser closes. A lot of my friends are buying MacBook Pros with at least 24 gigs of RAM specifically for this purpose.

With persistence, your agents can run on schedules. Every Friday, we run what we call a fleet audit, looking across all our websites and generating reports. Cam’s positive comments agent wakes up every day and scans Facebook, YouTube, and Google Business Profile for anything positive people have said.

These scheduled and triggered agents form an interconnected system where completing one task automatically kicks off the next.

Build an agent marketplace

Here’s where it gets interesting. Once an agent has done something enough times and proven its reliability, you can offer it to others. Think of it as the Upwork of agents.

You have a two-sided marketplace. On one side, customers who need work done. On the other, your trained agents ready to do it. Instead of charging a flat SaaS fee, you charge per task. Your cost might be a penny in tokens. The value to the customer might be five dollars. You find a fair price somewhere in the middle.

Scott Klintworth built agents for Sloan Appliance, which has 100 repair technicians.

He realized that plenty of other appliance repair companies use the same CRM and need the same workflows. His agents became products in the marketplace.

The compounding advantage

The most important point is this: recursive self-improvement creates proof. Every time an agent completes a task and writes a meta article, that’s documentation. That documentation turns into definitive articles, which turn into blog posts, YouTube videos, and demonstrable evidence that your system works.

This proof is your moat. Someone could copy your skill files, but they can’t copy the thousands of completed tasks and the relationships you’ve built.

Facebook open-sourced their code to run a social network, and nobody could replicate them because the real value was in the data and the network effects.

The same principle applies here. Break your business into clear, repeatable tasks. Document them. Train agents on them. Let those agents improve through repetition. Then offer that capability to others at a fair price.

If you believe in creating impact over income, you’ll ironically make more money by serving more people at a reasonable margin. Your agents can work with other people’s agents. Everyone shares their specialized capabilities through the marketplace, and the whole ecosystem gets stronger.

That’s recursive self-improvement. Not just for AI, but for your entire business.