Skip to content

As of

CABbing with AI: the change advisory board, and the weeks before it

Change management with AI agents shortens the slowest part of a change advisory board's work, which happens before the CAB meets: finding who owns a system, who depends on it and who has to approve.

Ask anyone who has filed a change how long the board took and they'll say a week, because it meets on Tuesdays. Ask how long it took to get onto the agenda and the answer is often longer. The meeting is the visible part. Most of the wait comes before it.

That earlier wait is made of questions. Who owns the system being changed? What depends on it? Who has to sign off, and is that still the person the form names? Each answer lives with a different team, and each one is found by asking.

What has changed is that most of those answers are already written down in the systems that run your organization. HR knows who reports to whom. Your identity provider and apps record who owns and administers each app. An AI agent can read all of that before it acts, which changes both the weeks before the board and what the board is for.

What the CAB gets right

A CAB does useful things. It makes someone write down a change before making it, puts a second set of eyes on anything unusual, and leaves a record an auditor can follow.

ITIL itself stopped asking for a board on every change some time ago. ITIL 4 calls the practice change enablement and lets an organization delegate change authority, down to pre-authorized standard changes that never reach a board. If your team already runs standard changes as policy, you've done the part the framework recommends. Our ITIL guide covers how that fits with AI agents more broadly.

What ITIL doesn't tell you is how to find out, quickly and correctly, who a change affects and who should approve it.

Most of the wait happens before the CAB

Before a change can be judged, someone has to assemble it: an owner, the affected services, the people to notify, the approvers. Typing those in is easy. Knowing what to type is not.

The requester starts with whatever record they can find: an ownership spreadsheet, a wiki page, a field in an old ticket. Then they check it. The listed owner moved teams last spring. Their replacement isn't sure the app is theirs. The manager who should approve has changed twice since the approval path was written. Each correction is a message, a wait and sometimes a meeting, and each one runs on someone else's calendar.

Dependencies take longer still. The person changing a system knows what they built on it, not what other teams later connected to it, so they ask around, and the answer depends on who replies.

None of this is hard work. It's slow because it is coordination across departments, and unreliable because the records it starts from were written once and left alone. Our guide to how long service management implementation takes makes the same point about setting a platform up: the time goes on finding people, not configuring software.

Then the board meets, and judges the change on the form this process produced.

Do you still need a CAB?

For routine changes, no: a written policy plus a live check of owners, approvers and dependencies before each change judges risk better than a weekly meeting, and frees the board for changes that need it.

The evidence is older than AI agents. The 2019 State of DevOps research from DORA found that external change approval was not associated with lower change failure rates. If a board doesn't reduce failures, its real job was risk judgment, and that judgment depended on what the form said and what the room remembered.

So the question is what to feed the board, and what to stop sending it.

Why ownership records go stale

A spreadsheet or a change-management field is correct the day someone fills it in and wrong after the first reorganization. Nobody's job is to update it, so nobody does.

The systems your organization runs on stay current because work depends on them. When someone changes manager, HR records it, or payroll and reviews go wrong. When an app gets a new admin, the identity provider or the app records it, or the new admin can't do anything.

That gives a simple rule: read ownership and approval paths from the systems that have to be right, and stop maintaining a second copy that doesn't.

Sorting changes by what they touch

Once owners and approvers are known, the second question is risk. Most teams sort changes into standard, normal and emergency by type: a credential rotation is standard, a firewall rule is normal.

Sorting by type is where risky changes slip through. Two credential rotations can be the same type and carry very different risk. One account is used by a single test integration. The other quietly sits under payroll.

An example shows how. A team rotates the secret on a service account the change form says belongs to the expense tool's single sign-on. The board approves it as low risk, and the next morning the nightly HR export to payroll has failed, because years earlier someone pointed it at the same account. The form was complete; it described the change as its requester understood it.

Sorting by what the change touches works better. A standard change is one whose blast radius, measured at the moment it runs, stays inside limits your team has written down: the systems it reaches, how many people depend on them, whether anything regulated sits downstream. Inside those limits it runs. Outside them it becomes a normal change and goes to a person.

That makes the same change standard on Monday and normal on Wednesday if someone connects a new integration to the account in between. A form can't catch that. A check against live data can.

Writing a standard change as policy for an AI agent

A standard change written as policy needs four things, and most teams already have them in a runbook somewhere.

Scope. What kind of change this is and which things it may touch. For a credential rotation: service accounts your team owns, where nothing outside your team depends on the account.

Approvers. Who signs off when a check fails, named by role or relationship rather than by person: the app's owner as the identity provider records it, the requester's current manager in HR. A name typed into a form goes stale; a relationship read at the moment of the change doesn't.

Checks and rollback. What must be true before it runs, starting with the dependency check, and how the change is undone, written as steps. If the change is a workflow, the earlier version is the rollback.

Who's told. The owners of anything downstream of the change are a better list than a distribution group someone set up years ago.

Anything that fails a check doesn't fail quietly. It goes to the approver the policy names, with the dependency list attached.

How STLabs finds owners, approvers and blast radius with Axiom™

STLabs builds Axiom™, a live model of your organization's people, devices, apps and access, kept current from your HR system, identity provider, device management and cloud accounts. Axiom™ keeps track of how those records relate: who owns what, who reports to whom and what talks to what. Every fact records which system it came from and when it was observed.

That covers most of the chasing. Reporting lines come from HR, so a manager approval goes to the person's current manager, not the one on an old approval path. App owners and admins come from what your identity provider and apps record. Dependencies come from the connections Axiom™ already sees, so the requester doesn't have to know who connected what last year.

Axiom™ also shows what a change will affect before it goes live, by following the connections from the thing being changed to everything that depends on it. Our agent runs that check before every workflow, so a change that reaches further than expected is flagged before it breaks something. Your engineers can ask Axiom™ the same question before a change they make by hand: what depends on this service account, and who owns those things?

The rules live in Policies & Approvals. A policy says whether a change is allowed, blocked or needs approval, and who approves it. The workflow waits for the decision before it acts. Workflows are saved as versioned code, so any change to one can be reviewed and rolled back. Each policy decision is logged with the rule applied, the approver and the time, so an auditor asking why a change ran without a board gets the policy that allowed it and the check it passed.

Why a graph? "Who owns what is downstream of this account" is several hops, and a graph answers it as one walk. That's the architecture behind AI-native service management, and the reason nobody has to keep a CMDB current by hand (more in Graph over tables and What is an anti-CMDB).

A reviewer who can see an owner was read from the identity provider yesterday trusts the check.

How to test this on your own systems

Pull the last quarter of changes your board approved and pick ten.

For each one, measure two gaps: the days from when the change was first requested to when it reached the board's agenda, and the days from approval to the change being made. If the first gap is bigger, your delay is in assembly, not the meeting.

Then check each form against your systems. Was the named owner still the owner in your identity provider or the app? Was the approver still the requester's manager in HR? Finally, look at any change that failed in the same quarter and ask whether the dependency that broke was on its form.

If the forms matched the systems every time, your board is working and you have little to gain. If they didn't, the gap is in the input, and a faster meeting won't close it.

Keep the board for what an AI agent shouldn't decide alone

None of this means abolishing the CAB. Keep it for normal and emergency changes and for writing the policies that define a standard one. Deciding policy still takes people; finding owners and dependencies shouldn't. STLabs runs alongside the service desk you already run, so you can start with one change type, such as credential rotations, and go from integration to results in five days. The plan is in Moving to STLabs from your current service desk.

A board is only as good as the map in front of it.

Frequently asked questions

Do you still need a CAB in ITSM?

For high-risk changes, exceptions and writing change policy, yes. Routine changes can run as pre-authorized standard changes under written policy, with a live check of owners and dependencies deciding whether each stays standard.

Why do changes take so long to reach the CAB?

Mostly coordination. Before a change is judged, someone has to find who owns the system, what depends on it and who must approve, often from out-of-date records and across several teams.

Will auditors accept changes approved by policy instead of a CAB?

Auditors look for evidence of who authorized a change and why. A logged policy decision, recording the rule applied, the approver, the check passed and the time, gives them that without a meeting.

What is the blast radius of a change?

Everything that depends on the thing being changed: the systems, people and access downstream of it. In STLabs, Axiom™ shows a change's blast radius before it goes live.

See it on your tools.