Let’s be clear about what agentic AI actually does

Agentic AI is NOT a smarter chatbot. A chatbot just responds, but an agent acts.

Give an agentic system a goal and it will reason about how to get there, select the tools it needs, execute steps in sequence, adapt when something does not go as expected, and coordinate with other agents if the task requires it. In an IT service management context, that might look like an agent that handles an incident end-to-end: identifies the issue, checks the known error database, runs a resolution playbook, validates the outcome and closes the record. All of it, without a human approving each step.

The efficiency case is obvious. Anyone who has managed a service desk knows exactly what it would mean to handle that volume without burning out a team. But here is the part that does not make it into the vendor slides. Every single decision that an agent makes is only as good as the knowledge it acts on. If the knowledge is accurate, structured and current, the agent delivers. If the knowledge is outdated, ambiguous or incomplete, the agent executes confidently in the wrong direction. At scale, faster than any human would.

That is not a technology problem. That is a Knowledge Management problem.

What ITIL gets right, and what agentic AI asks of it next

ITIL 4 defines Knowledge Management as the practice of maintaining and improving the effective, efficient and convenient use of information and knowledge across the organization. The DIKW model sits at the centre of it:

• Data becomes Information;
• Information becomes Knowledge;
• Knowledge leads to Wisdom;

Right knowledge, Right person, Right time.

These are solid principles. The problem is that every one of those principles was designed with a human on the receiving end.

ITIL’s Knowledge Management practice was built around human knowledge workers, people who read between the lines, notice when something feels off, ask a colleague before acting on a knowledge article that seems outdated. However, agents do not do any of that. They execute what the knowledge record says, literally, as written, without hesitation.

An agent does not notice that the article it is referring to was last reviewed eighteen months ago and the system it describes was decommissioned in Q3. It does not sense that the resolution steps are missing a critical precondition. It just follows the process, hundreds of times, until someone notices the pattern and goes looking for the root cause.

That root cause will almost always trace back to the quality of the knowledge. And the good news is that knowledge quality is entirely within our control.

Four ways agentic AI breaks the current model

Before we can fix the problem, we need to be honest about where the current approach falls short. Working in GRC, I see four failure modes that come up consistently.

Agents consume knowledge literally. Human technicians bring context and judgment to every interaction. They interpret what an article means, not just what it says. Agents take it at face value. If the article assumes the reader already knows something or buries a critical caveat halfway through, the agent misses it. It just follows the steps as written. The gap between what the article says and what it means is invisible to a machine.

Agents can only work with what is written down. And most knowledge articles describe how a system was designed to work, not how it works today. Not the workaround your team figured out after the last incident. Not the process that quietly changed but never got updated in the documentation.

That gap between ‘system as designed’ and ‘system as found’ has always existed. Humans navigate it instinctively. They ask around, they remember, they fill in the blanks. Agents cannot. If the documented process diverged from reality six months ago, the agent has no way of knowing. It just follows the steps.

Agents generate knowledge at volume. Every resolved ticket, every escalation, every failure, all of this is data. Resolution steps that worked, patterns that keep coming up and gaps the agent could not close, all this is real learning. And right now, most of it is sitting in logs that nobody is reading. Without a process to capture and review it, it disappears or, in worst case, it accumulates as noise and quietly makes the knowledge base less reliable over time.

Agents propagate errors at speed. A flawed knowledge article encountered by a human technician might cause one wrong resolution before someone raises a flag. The same article consumed by an autonomous agent might drive hundreds of wrong resolutions before a pattern surfaces. That is not just a bigger version of the same problem. The scale changes the nature of the risk entirely.

Four things ITIL practitioners need to do differently

When we say we need to do 4 things differently, it doesn’t mean ITIL is wrong. It means we need to apply it more deliberately and extend it in areas the framework did not originally anticipate. Go with the philosophy, Adopt and Adapt.

1. Design knowledge for machines, not just humans

Traditional knowledge articles are written for human readers, with full sentences, context woven in and judgment left to the reader. Agents need something different: structured, explicit, machine-readable knowledge where scope is defined, preconditions are clear, outcomes are specified, and escalation criteria leave no room for interpretation.

This is not about dumbing things down. Making implicit knowledge explicit is actually better for everyone. Your human technicians will also benefit from knowledge articles that do not require them to read between the lines. ITIL has always said knowledge should be fit for purpose. The purpose now includes machine consumption, and that changes what fit looks like.

2. Govern the full agent knowledge lifecycle

Agents participate in every stage of the knowledge lifecycle: they consume knowledge, they generate signals through every interaction, and over time they quietly expose which articles are not fit for purpose because resolution rates drop and escalations go up. None of that happens visibly without deliberate governance.

You need to define which knowledge sources agents are authorized to act on. You need quality thresholds that a knowledge record must meet before it is exposed to autonomous agents. You need a review process for agent-generated insights before they get promoted to formal knowledge. And every knowledge record that an agent acts on needs a human owner who is accountable for its accuracy. Ownership does not become less important in an agentic environment. It becomes the primary safeguard.

3. Treat knowledge quality as an operational risk metric

ITIL links Knowledge Management to continual improvement. Agentic AI gives us the data to make that connection measurable. When an agent resolves an incident incorrectly, trace it back.

What knowledge did it act on?

When was it last updated?

Who owns it?

When an agent escalates at an unusually high rate, that is a signal worth investigating, it usually means the knowledge base has a gap the agent cannot resolve autonomously.

Knowledge quality is no longer a soft metric. It is an operational risk with direct service impact.

This is a governance question, not a technology question

Across everything above, one thing stays constant. The value an agentic AI system delivers is bounded by the quality of the knowledge it operates on. In simple terms, you put garbage in the system, you get garbage out.

If we get the knowledge right, the agent resolves incidents faster, surfaces patterns humans miss, reduces escalation rates and delivers outcomes that were not possible at this scale before.
That is Transformation!

That is what the promise of agentic AI actually looks like when it is done well.

If we get the knowledge wrong, then we are only building a very fast, very confident system that is moving in the wrong direction. It looks like efficiency, but it performs like a liability. And when things go wrong, the root cause will always trace back to the same place: “Nobody took Knowledge Management seriously enough before the agents went live”.

The ITIL community is well placed to solve this. Not because the framework was written with agents in mind, but because the principles of accountability, ownership, continual improvement and fitness for purpose are exactly what agentic environments need most.

We just have to be willing to apply them with the seriousness the moment demands.

The agents are ready. The question is whether the knowledge infrastructure behind them is, and that answer is entirely up to us.