Start here: the road to an agentic enterprise

An agentic enterprise is a company where governed agentsAgent. Software that uses an AI model to work toward a goal on its own: it reads, decides the next step, uses tools, and keeps going until the job is done or a limit stops it. do the routine knowledge work. People set the intent, supervise the work and handle the exceptions. They stay accountable for the result. Picture a modern bottling plant. The line runs on its own, and a few skilled people step in when a machine jams. Knowledge work is heading the same way. Three ideas frame the guide: layers you own, a lifecycle you run, capabilities you add. You already own fourteen layers of systems, from infrastructure to agent data. Every agent passes through one lifecycle, from register to retire. You add seven capabilities across the layers so agents can run safely. This page puts the guide into seven steps. Each step lists the pages to read, in order. Each ends with a gate: what must be true before you move on.

What changes

"Today" means how most companies work now, including their first agent pilots.

The gateway and the policy decision point are services outside the model. They allow or block each action. Evaluations (evals) are fixed tests that a change must pass before release. Enforcement outside the model and the learning flywheel explain both.

1. Understand

Learn the shape of the system before you change anything.

1. Architecture of the agentic enterprise: the three ideas, told as one story.
2. What an agent platform provides: the seven capabilities and the two rules.
3. The agent lifecycle: the nine stages every agent passes, from register to retire.
4. Follow one inspection task: one task, from goal to confirmed result.
5. Vision and target state: the full research view.

Gate: the sponsors can say what changes and what stays.

2. Assess readiness

Find out how far the organisation can go today.

1. The readiness assessment: seven readiness areas, each scored on its own.
2. The autonomy contract: readiness caps how freely an agent may act.

Gate: a readiness profile, and the autonomy ceiling that follows from it.

3. Choose use cases

Pick work you can judge, protect and supply with evidence.

1. Choose where to start: the checks a first task must pass.
2. Agents and packaged applications: wait for the vendor's agent, buy it, or build a thin one.
3. Measure value and full cost: the business case, with review and rework counted.
4. Industries: worked examples in healthcare, energy and utilities.
5. The use-case portfolio: compare value, cost, risk and supervision load.

Gate: the use case is admitted and its risk tier is set.

4. Design

Turn the use case into an agent you can bound.

1. What kind of agent is this? Four questions: its role, permissions, autonomy and impact.
2. The autonomy contract: the autonomy and learning levels, and the ceiling readiness sets.
3. The risk profile: score the agent to set its tier. The tier sets the controls.
4. The deterministic zones: the areas where a model may never approve.
5. The delegation chain: trace every action to the person who asked.
6. The agent lifecycle: register the agent, name its sponsor and owner, and set what it may reach.
7. Enforcement outside the model: where the controls sit.
8. The data-to-memory pipeline: from company data to a cited answer.
9. The fourteen layers: what each part of the estate must provide.
10. The threat model and the decision catalog: what can go wrong, and the technology choices with verdicts.

Gate: the zone register is signed and the controls are chosen. The zone register is the one-page list of who decides in each zone.

5. Build

Build the agent and test it before anyone relies on it.

1. The intelligence ladder: the order in which to try changes.
2. Choose what to change: match the change to the failure.
3. Knowledge and memory: give the agent the evidence it needs.
4. The Agentic OS: the runtime you buy and the harness you build.
5. Context patterns: tested ways to give an agent the right context.
6. The learning flywheel: the evals a change must pass.

Gate: the evals pass and the approvals are signed.

6. Operate

Run the agent, watch it, and count what it costs.

1. Operate: the weekly loop: the four checks to run every week.
2. The observability and FinOps layer: traces the agent cannot forge, and budgets with hard limits.
3. The operating model and supervision layer: how much supervision the work really needs.
4. The agent lifecycle: the operate, change, periodic review and retire stages.
5. Measure value and full cost: compare the result with the old process.
6. The economics model: the full cost of each outcome.

Gate: oversight capacity holds at peak load, not just on an average day. Oversight capacity is how much exception work people can clear in time.

7. Scale autonomy

Let a proven agent do more, one level at a time.

1. The autonomy contract: the controls and checks that earn each higher level.
2. The learning flywheel: improve behaviour without losing control of it.
3. The risk profile: how outside autonomy scales map to this guide's levels.
4. Build an agentic enterprise: share what works across the company.

Gate: each move to a higher level waits until readiness, controls and oversight capacity all allow it.

The next use case starts again at step 3.

Who owns each step

A chief information officer (CIO) owns steps 1, 2 and 7. They set the intent and accept the readiness profile. They decide when an agent may act more freely. They also fund the use cases chosen at step 3.

An enterprise architect owns steps 4 and 5. They turn each use case into a designed agent. That means its four answers, its risk tier, its zones and its controls. They make sure the build passes its evals.

A programme lead owns steps 3 and 6. They choose the use cases and set up each trial. They run the agents day to day and measure the value. They bring each new use case back to step 3.

The evidence behind each page

Most pages end with a section called evidence and limits. It says what the sources support and where they stop. Dated sources sit in a collapsed block at the foot of each page. The research tab holds the experiments and the open questions. The research library holds the layer research. The re-verification list dates the facts that change fast, such as product names and prices.

Next step: begin step 1 with Architecture of the agentic enterprise.