AI Lifecycle & Structure: Agents Don’t Retire Themselves
Let me start this article with a simple question: “how many AI agents do you actually have running right now?”
If that created a slightly uncomfortable pause whilst you racked your brains, looked to ceiling and counted aloud. Like the X Files, you are not alone.
In 99.9% of cases, nobody knows the answer. Someone always knows about some of them. But almost never, does any one person know about all of them – at least the sanctioned ones. And almost nobody can say with any confidence, which ones are still doing useful work, which ones were built but broken, and which ones you tried to scale but failed.
This is a different governance failure to the one described in Part 1 of this series, where the issue was what your AI agents can access. This problem occurs after you’ve built and deployed an AI agent. For most businesses right now, that’s very little. Nothing much happens after an agent goes live. It either keeps running indefinitely or until something breaks or someone notices.
You already know how to manage a workforce over time
You do this all the time, with people, managing what changes, ages, and eventually needs replacing or retiring.
You hire employees for specific roles. They’re onboarded, performance reviewed, invest in their development, add or remove responsibilities, occasionally reassign them, and eventually, when they’re no longer a fit, they move on. It’s safe to assume that most employees hired in five years ago are NOT still doing exactly the same job today, in exactly the same way, with exactly the same access, without anyone checking on them.
Your AI Agents need a very similar discipline and approach. Another question: “Are you actively managing yours this way?”
An agent that worked well when it was built might not remain appropriate forever. There are several reasons or causes for this, for example: the underlying model will always get updated or replaced; the business process that it supports will evolve, sometimes significantly, and an agent doesn’t update its own configuration; costs will inevitably creep up as usage scales, in the way explained in Part 4; a better tool or approach comes along and quietly replaces the existing agent. The problem is that nobody retires it, because that requires someone to remember and actively decide to do it.
McKinsey has a useful word to describe this: abandonware. Technology that stays inside the business long after everyone’s stopped thinking about it. It’s not a new problem, IT departments have dealt with abandoned software and forgotten licences for decades. We’ve seen this with macros, Power BI, SaaS applications, desktop automations, workflow automations, the list goes on, but it becomes more serious with agents, because an abandoned agent isn’t just sitting there costing a subscription fee. It’s still acting. Still accessing data. Still making decisions or taking actions inside your business, unsupervised, because nobody remembered it was there to check.
Small numbers hide the problem. Scale exposes it
If a business has only five or ten agents, this is managable through sheer lack of scale. Someone probably knows about all of them, roughly what they do, and would likely notice if one started behaving oddly. Informal management simply works better at smaller scale, mostly by proximity than by design.
That stops working so well once this scale up. A firm with dozens or hundreds of agents, spread across multiple processes (bookkeeping, onboarding, reporting, meetings, notifications and reminders), can’t rely on someone remembering and checking – a risk with automating, is out of sight, out of mind. At that point, this structural risk sits quietly inside your business, and stays invisible until something goes wrong.
I’ve seen this happen before, long before generative AI, with process automation portfolios that grew without being as actively managed as they should. Bots were deployed and worked well for years while the processes and systems changed around them. What they lacked was the formal lifecycle, the operating model, that kept them present and relevant.
The lifecycle an agent actually needs
Part 1 introduced the Agent Development Lifecycle (“ADLC”) as the framework for how an AI agent comes into existence properly, and the second half of that discipline, is what happens to the agent once it exists.
A proper agent lifecycle needs a small number of things most businesses currently don’t have. A clear point of onboarding, where the agent goes live with a defined owner, a defined purpose, and a record of what it was actually built to do. A regular, scheduled and structured review, instead of a knee-jerk reaction for if/when you notice a problem. And a genuine retirement path, because an agent that no longer serves a purpose should be switched off deliberately, and not left running because switching it off feels like more effort than leaving it alone.
Drowning in manual, repetitive work? Tell us the task and we’ll show you what to automate.
That last point is the one most businesses find easiest to do and the most uncomfortable to deal with. Retiring anything is almost impossible, and we usually resort to leaving it “just in case”. In reality, retiring an agent that’s no longer earning its place is exactly the same discipline as retiring a piece of software, a process, or a person that’s outlived its usefulness. It’s not a failure. It’s what a mature operating model does as a matter of course.
This is what makes autonomy manageable
I want to be clear that this isn’t about adding bureaucracy for the sake of it, or slowing down every agent with layers of review that make the whole exercise not worth doing. Getting real value from AI agents right now is about moving quickly, so speed matters.
But speed and structure aren’t opposites. A proper lifecycle doesn’t stop you from moving fast, it’s actually what allows you to keep moving fast without losing track of what built and live. Ten agents can be managed informally. A hundred definitely can’t. If you can get ahead of this now, while your agent count is still manageable, you’ll find scaling far less painful than waiting until you’ve lost count.
Practical starting points
In each part of this series, I’ll leave you with some practical next steps and some links to helpful tools to get you started, so here’s your AI Lifecycle imperatives.
Do a full agent inventory, right now, today. Not an estimate. An actual list of every agent currently running, who built it, who owns it, and what it’s supposed to be doing. If this list doesn’t exist yet, building it is the single most valuable thing you can do this week.
Give every agent an owner and a review date at the point it goes live. Not after the fact. Build this into the ADLC itself, so onboarding an agent without a named owner and a scheduled review simply isn’t possible.
Set a genuine retirement trigger, not just a build trigger. Decide in advance what would make an agent redundant, model change, process change, better alternative, and check for those triggers on a schedule rather than waiting to notice by accident.
Identify your red flags. If nobody can immediately say what an agent does or why it still exists, that’s not a minor admin gap, that’s the abandonware risk in effect.
Build retirement into the culture, not just the process. Make switching off an agent that’s no longer earning its place a normal, unremarkable act of good management, not something that feels like admitting failure.
Know where you stand
Most businesses can tell you roughly how many AI agents they’ve built. Almost none can tell you, with confidence, which ones aren’t broken and still earning their place, who owns them, or which ones have quietly become the thing nobody remembers building.
Our AI Agent Lifecycle Assessment helps to give you the full picture: a full inventory of your existing agents, a clear read on ownership and abandonware risk, and a working register you can keep using to review and retire agents on a proper schedule, rather than by accident.
Contact us to get the AI Agent Lifecycle Assessment tool for your firm.
Next in this series: Part 6, AI Agent Control & Orchestration, and why the next competitive advantage in AI won’t be who has the most agents, but who actually knows how to manage them.
