A few weeks ago, a client of mine, a start-up CEO from the US, asked me how to make his system self-learning: software that improves on its own, so the competition never catches up. He is not alone. The founders he talks to want the same thing, and honestly, I find the idea inspiring. But between the dream and what your software can do today there is a gap, and it sits on three levels: the system, the process, and the codebase. The video above is the full walkthrough; this is the written version, for skimming and for sending to whoever owns your roadmap.
Level one: the system has to give agents a way in
For AI to work inside your product, it needs a communication layer built for agents. Most systems don’t have one, and that, more than anything else, is the bottleneck.
The simplest way to see it: ask Claude to send an email, and it does it nicely, because Gmail plugs into AI. Now ask it to create a lead in your ten-year-old custom CRM, and it will tell you it just can’t. The difference is not intelligence. Gmail gives agents a way in; your CRM doesn’t. And it doesn’t matter whether the thing knocking is a bot, an automation, or an integration: they all need the same thing.
The tempting shortcut is “we already have an API, just plug the AI into that.” Even Anthropic, the company behind Claude, lists wrapping existing endpoints as a common error in its guidance on building tools for agents. This layer is its own engineering. You design it differently, you test it differently, and you add things most systems simply don’t have today: guardrails and logging. You decide what the agent may do on its own, what needs a human click, and what it may never touch. And you log every decision, what was done and why, because when an agent refunds the wrong customer, “the AI did it” is not an incident report.
So before AI can work in your product with any freedom, the product has to be ready for it: either rebuilt to the new standard, or with a new layer built on top of it.
Level two: the process can’t live in people’s heads
You can’t hand a process to an agent if the process lives in people’s heads. Writing it down is not bureaucracy; it is the delegation itself.
Try this one yourself. Ask ChatGPT to write a proposal for a client from the accounts of two different people, and you get two fundamentally different documents: different length, different language, different content. But give it a documented process with a template, and it puts the effort in the right places. It preserves the spine, adjusts the copy, alters the price, and replaces the client’s details based on the call transcript. It doesn’t drift away from the rules you set, and that is the whole point.
If the edge cases get handled because one person just knows what to do, there is nothing to hand over. My test: if you can’t delegate it to a smart intern with a one-page checklist, you can’t delegate it to an agent either. AI is a multiplier, and it multiplies whatever you feed it. Feed it a fuzzy process, and it will execute the gaps at machine speed.
Level three: the codebase has to survive an agent’s changes
A product that improves itself means an agent commits code to your product. That is only safe on a codebase with tests that work as guardrails, docs an agent can actually read, and releases that run on their own.
Here is what the full dream looks like. Your customers keep sending one extra detail every time, right after they sign up; it shows up in every support thread. The AI notices the pattern and decides this information belongs in the sign-up form. It adds the field, ships it, and then checks: did those support messages stop? That is a product improving itself. Nobody wrote a ticket, nobody planned a sprint. The product saw its own gap and closed it.
It really is that good, and to be fair, this layer is the youngest of the three. If somebody promises it to you next sprint, that is a tell. Because here is the catch: the agent will make that change either way, confidently, rating its own work ten out of ten. If your codebase has tests and docs, the change ships and the tests prove nothing else broke. If it doesn’t, nobody knows what just broke three screens away: not you, not the agent. Your customers find out first.
You can’t delegate changes on a codebase that fights every release. What makes it safe is the same discipline that makes human teams fast; agents just make the gaps show up sooner.
What’s real today, and one number to keep you honest
The technology is here. We have used it, and it is capable of everything above the third level’s frontier. What I haven’t seen is many companies using it in a meaningful way yet, because it takes a different approach and a different skill set on all three levels.
The number: Gartner looked at this in June 2025. Of the thousands of vendors calling themselves agentic, they estimate only about 130 actually are; they even coined a name for the rest, “agent washing.” So when you hear a big promise, walk it down the three levels: the system, the process, and the codebase. It is the same discipline we put on the buying side in our vendor checklist: the AI question and the handover question are this standard seen from the other chair.
As for us, we are on our path to the Claude Partner Network certification, keeping up with the newest in the space, so we can help tech companies get up to speed on all three layers. If you want an honest read on where your product stands today, that is exactly what our audit is for.