Skip to content

Rapid ITIL

Re-thinking Change, Governance, and Control in the Age of Automation and AI

Executive Summary

Enterprise IT service management was designed for a world where change was slow, manual, and infrequent. Modern infrastructure is automated, API-driven, and continuously changing — yet governance models have not evolved at the same pace.

Rapid ITIL introduces a modern operating model for IT governance that preserves the core principles of ITIL — control, accountability, and auditability — while enabling high-velocity, automated change across complex enterprise environments.

Rather than treating change as a sequence of approvals and tasks, Rapid ITIL treats change as a declarative commitment to maintain a verified state, continuously enforced and validated through automation and AI.

This article introduces the Rapid ITIL governance model, then presents the Universal Executor — an LLM-driven execution layer that makes continuous governance practical at enterprise scale.

Part One: The Governance Problem

Traditional ITIL Does Not Scale

1. Change Volume Has Exceeded Human Governance

  • Infrastructure is now software-defined and API-driven
  • Cloud, network, security, and platform changes occur continuously
  • Manual CAB processes were designed for tens of changes per week, not thousands

Result: governance becomes a bottleneck or is bypassed entirely.

2. Governance Has Become Implicit

To cope with speed, organisations have introduced:

  • Pre-approved change patterns
  • Template-based automation
  • Scripted runbooks

While this improves velocity, governance is now assumed, not enforced. Approval moves earlier, verification moves later — or disappears.

3. Verification Is Coupled to Execution

In most modern pipelines:

  • If automation completes successfully, the change is assumed to be correct
  • There is no independent verification that:
  • The requested intent was satisfied
  • No unintended access or exposure was created
  • The system remains compliant over time

Execution success is mistaken for correctness.

4. Audit Evidence Is Retrospective

  • Compliance evidence is reconstructed after incidents
  • Drift between intended and actual state accumulates silently
  • Failures are detected reactively rather than prevented

This creates risk, especially in regulated environments.

Part Two: Rapid ITIL — A New Governance Model

Rapid ITIL redefines how change is governed without abandoning ITIL principles.

Core Shift

From:

"Approve the action before it happens."

To:

"Continuously verify that the declared outcome is being maintained."

Key Principles of Rapid ITIL

1. Change Is a Declarative Commitment

A change is not a script or a task. A change is a statement of intent:

  • What outcome is desired
  • What constraints must be respected
  • What ongoing state must be maintained

This intent becomes the authoritative source of truth.

2. Verification Is Independent of Execution

Execution and verification are treated as separate concerns:

  • Execution performs the change
  • Verification validates that:
  • The declared intent has been met
  • No prohibited conditions exist
  • The system remains in compliance over time

Verification does not assume execution correctness.

3. Governance Is Continuous, Not Point-in-Time

Rapid ITIL shifts governance from:

  • One-time approval → continuous assurance

Verification runs:

  • Before execution (pre-conditions)
  • After execution (post-conditions)
  • Continuously (drift detection and reconciliation)

4. Automation Is Governed, Not Exempt

Automation does not bypass ITIL — it operates within it.

  • Automated changes are subject to the same intent, verification, and audit requirements
  • High-frequency changes become safer, not riskier
  • Governance scales with change volume

The Rapid ITIL Change Lifecycle

1. Declare Intent

  • Desired service state
  • Constraints and policies
  • Ownership and accountability

2. Verify Feasibility

  • Validate intent against policy, architecture, and constraints
  • Identify conflicts or risks before execution

3. Execute

  • Perform the required changes using automation
  • Execution mechanisms are implementation-specific

4. Verify Outcome

  • Confirm the declared state has been achieved
  • Validate security, access, and operational conditions

5. Observe and Reconcile

  • Continuously monitor for drift
  • Automatically reconcile or flag deviations

Rapid ITIL vs Traditional ITIL

Traditional ITIL Rapid ITIL
Ticket-driven Intent-driven
Point-in-time approval Continuous verification
Manual CAB focus Automated governance
Execution-centric Outcome-centric
Reactive audit Proactive assurance

Part Three: The Execution Problem

Rapid ITIL describes what governance should look like. But a governance model is only as good as the execution layer beneath it.

Rapid ITIL assumes infrastructure that can:

  1. Translate intent into action across diverse platforms
  2. Verify outcomes independently of execution
  3. Detect drift continuously
  4. Reconcile state automatically
  5. Learn and adapt when things go wrong

Building this execution layer has historically been the hard part.

The Integration Bottleneck

Enterprise infrastructure spans dozens of platforms — cloud providers, network vendors, security tools, SaaS platforms. Each has different APIs, authentication models, and quirks.

Traditional automation requires hand-coded integrations for each platform:

  • Terraform providers
  • Ansible modules
  • Custom scripts and adapters

This creates a bottleneck. Adding a new platform means weeks of integration work. Maintaining integrations as APIs evolve becomes a full-time job. Niche or internal platforms remain unautomated.

Rapid ITIL governance cannot scale if the execution layer cannot scale.

The Reconciliation Gap

Continuous verification requires continuous execution. The system must repeatedly:

  • Check current state against declared intent
  • Identify deviations
  • Execute remediation
  • Verify the fix

Traditional automation tools are designed for one-shot execution, not continuous loops. They deploy and walk away. Drift accumulates silently until the next manual intervention.

Rapid ITIL requires infrastructure that converges toward declared state, not diverges from it.

The Verification Dependency

In most automation pipelines, verification is coupled to execution. If the script completes successfully, the change is assumed correct.

But execution success is not the same as outcome correctness:

  • The API returned 200, but did the configuration take effect?
  • The resource was created, but is it accessible?
  • The policy was applied, but does it actually block what it should?

Rapid ITIL requires independent verification — checking that declared intent was actually achieved, not just that commands ran.

What The Execution Layer Needs

To enable Rapid ITIL at scale, the execution layer must provide:

Capability Why It Matters
Universal integration Governance must cover all platforms, not just those with pre-built support
Continuous reconciliation State must converge toward intent, not drift away from it
Independent verification Outcomes must be validated, not assumed from execution success
Self-correction Errors must be learned from and adapted to, not just logged
Observable state Current state must be visible for audit and governance

Traditional automation tools provide some of these. None provide all of them.

Part Four: The Universal Executor

The Universal Executor is an execution model designed for Rapid ITIL governance.

Instead of hand-coded integrations, it uses LLMs to translate intent into API calls by reading documentation. Instead of one-shot execution, it runs in a continuous loop that reconciles state. Instead of assuming success, it verifies outcomes independently. Instead of failing on errors, it learns and self-corrects.

How It Works

1. Context Documents Replace Integration Code

Rather than writing code for each platform, you provide documentation — API schemas, authentication details, examples, constraints. The LLM reads this documentation and understands how to interact with the platform.

Adding a new platform takes hours, not weeks. No engineering required.

2. Intent Drives Execution

Users declare what they want — in natural language or structured specifications. The LLM translates this intent into the specific API calls required for the target platform.

The user focuses on outcomes. The system figures out implementation.

3. Continuous Loop, Not One-Shot

The executor runs continuously:

  • Execute changes to achieve declared state
  • Verify that the state was achieved
  • Monitor for drift
  • Reconcile when drift is detected

Infrastructure converges toward intent rather than diverging from it.

4. Self-Correction Through Feedback

When API calls fail, the errors are captured and fed back to the LLM. Subsequent execution cycles learn from failures and adapt.

The system improves through use. Edge cases are learned. API quirks are handled.

5. Observability Built In

The same execution loop that manages configuration can collect metrics and evaluate SLOs. Observability is not bolted on after deployment — it is part of continuous state management.

Role of AI in Rapid ITIL

AI is not used to replace governance judgement, but to scale it.

AI can:

  • Interpret high-level intent and translate to implementation
  • Generate verification conditions
  • Analyse complex change impacts
  • Identify anomalous states and drift
  • Learn from failures and adapt execution
  • Reduce manual review effort

Crucially, AI operates within explicitly defined intent and constraints. Humans declare what should happen. The system figures out how.

Enabling Rapid ITIL Principles

The Universal Executor directly enables each Rapid ITIL principle:

Change As Declarative Commitment

Intent is declared once and continuously enforced. The executor maintains the commitment over time.

Verification Is Independent

Verification queries actual system state, not execution logs. Outcomes are confirmed, not assumed.

Governance Is Continuous

The execution loop repeatedly validates that actual state matches declared intent. Drift is detected and remediated automatically.

Automation Is Governed

Because intent is explicit, execution is logged, and verification is independent, automated changes are fully auditable. High-frequency automation becomes safer, not riskier.

Benefits of Rapid ITIL + Universal Executor

Operational

  • Faster change without sacrificing control
  • Reduced manual review overhead
  • Early detection of misconfiguration and drift
  • Any platform automatable without integration work

Governance

  • Continuous compliance rather than snapshot audits
  • Clear accountability tied to declared intent
  • Stronger separation of duties
  • Full audit trail of intent, execution, and verification

Risk

  • Reduced blast radius of automation errors
  • Independent verification of outcomes
  • Self-healing infrastructure that converges to correct state
  • Improved resilience in regulated environments

Part Five: From Theory To Practice

This is not theoretical. NetOrca Pack implements the Universal Executor model in production.

Pack is an extension to the NetOrca platform that brings autonomous, LLM-driven execution to infrastructure automation:

  • Context Documents define target platforms — any API becomes automatable
  • Service Specifications describe desired outcomes — users define their own services
  • Continuous Execution runs in a loop — deploying, verifying, reconciling
  • Self-Correction learns from failures — the system improves over time
  • Observability collects metrics as part of the same loop

NetOrca customers define their own services and their own context documents. The platform does not dictate what can be automated — customers bring their own APIs.

This model is currently deployed at a tier-1 UK bank, managing infrastructure changes across hundreds of consumer teams.

See It In Action

The following demonstrations show Rapid ITIL governance and Universal Execution managing real infrastructure:

Demo Part 1: Deploying Infrastructure from Natural Language Specification

Watch Demo Part 1

Demo Part 2: Self-Correction After API Error

Watch Demo Part 2

Conclusion

Rapid ITIL is not a replacement for ITIL — it is its evolution.

As automation and AI accelerate the pace of change, governance must evolve from controlling actions to assuring outcomes. By treating change as a declarative, continuously verified commitment, Rapid ITIL enables organisations to move faster without abandoning control, compliance, or accountability.

But governance requires execution. The Universal Executor provides the execution layer that makes Rapid ITIL practical — replacing integration code with documentation, running continuously instead of once, verifying outcomes independently, and learning from failures.

Governance and execution are two sides of the same coin. Rapid ITIL describes the governance. The Universal Executor provides the execution.

Together, they enable autonomous infrastructure at enterprise scale.

This is the foundation for IT governance in an automated, AI-driven enterprise.

NetOrca Pack is available now. Contact us to learn more.