How to Start Building Autonomous Operations, Stage by Stage

This is part 5 of 5 in a series adapted from our white paper, The Autonomous Operations Factory: the operating model that completes the AI software factory. Download the full white paper for the complete argument, figures and sources.

You do not build an operations factory in one move. You start with one stage on one set of services, measure what changes, and widen from there.

This final post covers the three things to do first: measure the autonomy you have, expand its coverage where work is waiting, and build the enablers that make the factory possible. It closes with how StackGen is building toward the model.

How do you measure operations autonomy?

A factory that cannot report on itself is not instrumented, and the industry does not yet have the measures it needs. Two are wanted.

• The Autonomy Index is the share of operational decisions resolved by agents without human escalation, weighted by risk and complexity.
• Autonomy Coverage is the share of the four stages running on agent-executed workflows at all.

Both should count every agent acting on the estate, whoever built it. The first read needs no instrumentation. You can score a stage from how work moves today: who decides, who relays, and where it waits. The enablers further down make that measurement precise and continuous.

Neither number is the point on its own. A high Autonomy Index over low Autonomy Coverage is a pilot rather than a factory. Together they are the leading indicators for velocity, reliability and productivity. Read them by line of business, team and agent type.

Higher autonomy improves the operational measures, which roll up to the business measures above them. Autonomous systems with full context can reduce time to restore through faster root cause analysis. They can also reduce change failure rate upstream, by understanding the development practices that lead to incidents.

Where should you expand coverage first?

Coverage expands on two axes: which stages run inside the factory, and which services those stages run for. Adoption happens one cell at a time, one stage against one tier of services, rather than everything at once.

• Start with the highest-payoff stage. Pick the stage where the cost of today's operations model is easiest to agree on. For many teams that is remediation, where the toil and business impact of incidents are high. Let your own baseline decide which stage has the biggest immediate opportunity.
• Start with the highest-payoff services. Payoff is where work is waiting rather than where the most is at stake: queue depth, change rate, and the share of requests that escalate. The most business-critical service is often the most change-controlled, which makes it the slowest place on the estate to prove anything. Remediation on a payment service is a sharper first test than four stages across the whole estate, provided that is where the queue sits. Put agents on real production traffic in the cell you pick, set to recommend and prepare rather than execute, and raise the autonomy level as agent performance earns it.
• Add stages, and measure what only the connections can move. A single-stage agent can improve change failure rate up to a point, then stops, because the remaining causes sit beyond a boundary it cannot see. Measure it as each new stage joins, so the value of the connection is visible.

What enablers does an operations factory need?

Connect the repository, pipeline, ticketing and observability systems, and build the shared context underneath them. Five actions make a strong foundation, and each unlocks something specific.

1. Give a service one identity across all four stages, so an agent can tell that the thing alerting and the thing deployed are the same thing.
2. Express policy as code with an append-only record, so an action can be refused before it executes and explained afterward.
3. Write objectives as numbers with owners, so an agent has something to work toward and a rule for stopping.
4. Declare intended state, so drift is detected rather than inferred.
5. Inventory which requests cross domains, so you know where the elapsed time goes before you spend anything.

How StackGen is building the Autonomous Operations Factory

Operations needs more coordination than point agents can deliver, and we are building for that in three ways.

Multiple entry points. Aiden for InfraOps, Aiden for DevOps, Aiden for Observability and Aiden for SRE are generally available today. Each provides value on its own, and each is built to integrate with the others.

The shared context underneath them. The world model is what turns four products into one factory, rather than four tools that happen to be adjacent. The work now is breadth: connecting more sources so that more of the estate is represented.

One governance layer for every agent. The agent operating system is in production. Policy, identity, cost ceilings and the audit record apply to agents you built and agents you bought elsewhere, on the same terms as ours.

From having agents to running a factory

To keep up with the pace of change the software factory now produces, the industry needs an operations factory. Two years of adding intelligence to individual operational tasks as point agents has moved us forward. The next leap requires agents that share a picture of the system, a common set of objectives, and a governance layer that holds whoever built them.

That is the shift from having agents to running a factory. The organizations whose operations keep pace with development will not be the ones with the most agents. They will be the ones whose agents work from the same context, toward the same objectives, inside guardrails somebody can audit.

Download the Autonomous Operations Factory white paper

This post is part 5 of 5 drawn from our white paper. The full paper brings the series together in one place, with the figures, the market map and every source. Download the white paper.

The series

1. Part 1: AI Coding Gains Have Moved the Bottleneck to Operations
2. Part 2: Why More AI Agents Won't Shorten Your Operations Loop
3. Part 3: The Four Components Every Operations Factory Needs
4. Part 4: How AI Agents Coordinate Across the Operations Lifecycle
5. Part 5: How to Start Building Autonomous Operations, Stage by Stage (you are here)