As of
ITIL without the paperwork: how ITIL practices work with AI agents
ITIL is still the right framework for IT service. What AI agents remove is the paperwork that grew up around it.
ITIL organized IT work around ideas that hold up well. A service request is a standard need, handled the same way every time. An incident is not a problem. A change carries risk, so someone assesses it first. Most IT teams still think in these terms, and they should.
The trouble was the implementation. The service management platforms built in the 2000s turned each idea into its own module, with its own forms, queues and records. A request waited while each step's paperwork got done, and that waiting is most of what people mean when they say tickets are slow. The paperwork existed for a good reason: when people did every step, forms and queues were how they coordinated.
When an AI agent does the routine steps, most of that coordination isn't needed. The ITIL concepts stay. The structure that carried them collapses into something much simpler.
How do ITIL practices change with AI agents?
The practices stay and the paperwork around them goes. Every ITIL concept still applies; what changes is the structure that carries it out.
ITIL began in the late 1980s as UK government guidance for running IT services. The current version, ITIL 4, came out in 2019 and organizes service management into 34 practices. It's a framework, not software. An incident is still not a problem, change still needs an owner, and auditors will still ask who asked, who approved, what changed and when.
ITIL 4 already points this way. "Optimize and automate" is one of its seven guiding principles, and its change enablement practice lets change authority be delegated, down to pre-authorized standard changes that never go to a board. Most of what follows is allowed by the framework as written. In ITIL 4's terms, the agent takes on much of the deliver and support activity in the service value chain, while people keep plan and improve.
How ITIL practices fit a simpler structure
With an AI agent, every ITIL practice fits into four parts.
Policy says what's allowed, what needs approval and who approves. Service request models, standard changes and access rights become rules your team writes once in Policies & Approvals.
Facts say who and what exists and how it connects. Axiom™, the live model of the organization STLabs builds from HR, identity and device systems, holds the configuration items and relationships a CMDB was meant to hold, read from the systems that own them.
The agent does the work within policy, using the facts: fulfillment, triage, routing and the first look at every problem.
The record shows what happened, why, and which policy allowed it. STLabs logs every AI decision, workflow run and configuration change, so the ticket history, the change record and the access review evidence are written as the work happens.
People own the policy, the exceptions and major incidents, the parts that always needed judgment.
What happens to the service request?
ITIL's idea was a standard need handled the same way every time. Most platforms built it as a service catalogue: a form, an approval chain and a fulfillment queue for each item, configured one at a time. Employees had to find the portal, then the right item among hundreds, then answer questions the company already knew.
With an AI agent, the service request stays and the catalogue goes. An employee asks in Slack or Teams, in their own words: "I need Salesforce access." If a policy covers the request, the agent fulfills it end to end and records which policy allowed it. If no policy covers it, the agent opens a ticket for them, with their role, device and access already attached.
Approvals follow the same rule. The policy says when one is needed, and Axiom™ knows who reports to whom from HR, so the request goes to the current manager rather than whoever the form listed.
What happens to incident and problem management?
ITIL separates restoring service from finding the cause, and that distinction still matters. What goes is the ladder. Instead of a ticket climbing from L1 to L2 to L3 with context gathered at each step, it's triaged on arrival: categorized, prioritized and routed with the requester's identity, device, access and recent changes attached.
Problem identification moves from hindsight to the moment it happens. Tickets that share a root cause are grouped as they arrive, so a known error shows up as one problem rather than dozens of incidents, and reports about a slow app, an unreachable file share and VPN drops can be traced to one firewall rule change. A major incident still goes to people, with the picture already assembled.
How does change enablement work with an AI agent?
On most platforms change management is a module of its own: change records, risk questionnaires, change templates and a weekly change advisory board.
With an AI agent there's no separate module. A change goes through the same parts as any request. Policy decides which changes are pre-authorized standard changes and which are normal or emergency changes that need the change authority. Axiom™ shows the blast radius before a change goes live by following the connections between people, devices, apps and access, and the agent runs the same check before every workflow. Workflows are versioned, so any change can be reviewed and rolled back.
The change authority still exists. It reviews the changes that are actually risky, instead of every change that has a form.
What happens to access when someone changes roles?
ITIL treats access management as part of information security management: people get the access their role needs and lose what it doesn't. On most platforms that runs on tickets, so it only happens when someone files one. People ask for what they're missing, not for what they should lose.
Take a marketing operations manager who moves to sales operations. Two access requests go in over four days, both route to the old manager because that's who the form lists, and the new job waits eleven days. Nobody files a ticket to remove the marketing admin rights, so the quarterly access review finds them and they end up in the audit report. Every ticket followed ITIL, and the outcome was still wrong.
With an AI agent, the role change in HR is the trigger. Axiom™ picks up the change from Workday before anyone files anything, and the agent applies the policy for the new role: the new access that morning, the old access removed after a handover period. Because Axiom™ holds each person's access across every connected app, the removal also covers access picked up outside the request process, like an editor seat someone shared directly. Anything the policy doesn't cover, such as keeping one old permission through quarter close, goes to the approver the policy names.
At the next access review, the record shows who asked, which policy applied, who approved the exception and when each change happened. That is what AI-native service management changes in practice: the work happens where the facts change, and the record is a by-product of doing it.
ITIL practices with an AI agent, side by side
| ITIL practice | Before AI agents | With an AI agent |
|---|---|---|
| Service desk | A portal, an inbox and a phone line. Every contact is logged as a ticket. | Self-service in Slack or Teams: employees ask in their own words. Nothing is logged by hand. |
| Service request management | A catalogue form, approval chain and fulfillment queue for each item | One policy per request type. The agent fulfills it, or opens a ticket with the requester's context. |
| Incident management | Categorized by hand and escalated from L1 to L2 to L3 | Triaged on arrival and routed with identity, device, access and recent changes attached |
| Problem management | Problem records opened later from incident reports | Tickets grouped by shared cause as they arrive |
| Change enablement | A separate module: change records, risk questionnaires, a weekly CAB | Policy decides standard changes. Axiom™ shows the blast radius. The change authority reviews what's risky. |
| Service configuration management | A CMDB kept current by imports and discovery projects | Axiom™ reads people, devices, apps and access live from source systems |
| Knowledge management | Articles written by hand that employees rarely find | The agent answers from the knowledge base and past resolutions |
| Information security management (access) | A ticket for every join, move and leave. Moves are often missed. | Access adjusts when the role changes in HR. Orphaned accounts are flagged. |
| IT asset management | Software licenses reconciled each quarter | Unused licenses found and reclaimed, renewals tracked |
| Service level management | SLA timers that can stay green while people wait | Ask how long people waited and which requests needed a person |
| Continual improvement | Periodic reviews of ticket reports | Repeated work spotted and turned into a workflow |
Where ITIL programs go wrong with AI agents
Most of the trouble comes from fitting the agent into the existing paperwork instead of removing it.
The most common move is to put the agent in tier 1, because that's where the volume is. You get a well-categorized ticket arriving in the same queue a little faster, and nothing else. Make the agent the first pass on everything, and send people only what needs judgment.
The second is making a clean configuration database the price of starting. The facts an agent needs are already in the systems that own them: role and manager in HR, access in the identity provider, devices in device management.
The third is an approval in front of every action, which rebuilds the old process with one more participant. And if the dashboard still counts tickets closed on target, nothing else will change. By that measure, a role change that takes two weeks still looks fine.
How to test this on your own systems
The request that ITIL paperwork handles worst makes the best test. Move someone between teams and file nothing.
Change the person's team in your HR system and wait. Does the new access arrive without a request? Does the old access go on the date your policy sets? Does the exception reach the person who can approve it? A week later, ask whether an auditor could tell from the record alone who asked, which policy applied, who approved and what changed. If answering that means reading three tickets and an email thread, the paperwork is still there.
Keep ITIL, drop the paperwork
None of this means retiring ITIL or the service desk you already run. STLabs works alongside it with bidirectional sync, so you can move one request type at a time, starting with team transfers. Teams go from integration to results in five days. The plan is in Moving to STLabs from your current service desk.
Keep the concepts ITIL taught you and the record auditors ask for. ITIL was always about the outcome; the paperwork was how people got there.
Frequently asked questions
Is ITIL still relevant with AI agents?
Yes. ITIL is a set of practices, and they all still apply. What changes is the paperwork, because an AI agent can do the routine steps that forms and queues used to coordinate.
Is ITIL 4 compatible with AI agents?
Largely, yes. ITIL 4 includes "optimize and automate" among its guiding principles and allows pre-authorized standard changes. An AI agent acting within written policy fits that model.
Do we still need a CMDB if we follow ITIL?
You still need accurate configuration data. It doesn't have to be a database kept up by hand: an AI agent can read it live from your HR, identity and device management systems. See What is an anti-CMDB.
Does ITSM still need a change advisory board?
For high-risk changes and exceptions, yes. Standard, low-risk changes can run under written policy, with the board reviewing only what the policy can't decide.