The Agent Reliability Engineering Manifesto

Manifesto

Agent Reliability Engineering (ARE): A Framework for Reliable, Governable, and Trustworthy AI Agents in Production

Agents are intelligent.
They are not yet reliable.
Without reliability, you only have liability.

Version 1.0 · July 2026 · Open for contribution
Proposed by Mike Hogan

What Does Agent Reliability Engineering Address?

Agent Reliability Engineering (ARE) addresses the engineering problem of making AI agents reliable enough to operate safely, predictably, and accountably in production. It focuses not only on whether an agent can complete a task, but whether it can consistently operate within defined authority, policies, constraints, and recovery boundaries as conditions change.

What is Agent Reliability Engineering?

Agent Reliability Engineering (ARE) is a software engineering discipline for making AI agents reliable, governable, observable, recoverable, and accountable in production.

ARE treats reliability as an architectural property, not a runtime afterthought. It applies engineering practices across an agent's identity, authority, contracts, policy enforcement, evaluation, testing, runtime controls, observability, governance, and continuous improvement.

ARE extends the principles of Site Reliability Engineering (SRE) to autonomous AI systems whose behavior is probabilistic, adaptive, tool-enabled, and capable of making decisions and taking actions.

Why do AI agents need reliability engineering?

AI agents introduce a reliability problem that traditional software systems do not fully address. An agent may interpret ambiguous instructions, select different tools, encounter changing environments, generate unexpected plans, delegate work to other agents, or compound errors across multiple steps.

As agent capability and autonomy increase, the consequences of unreliable behavior increase with them. An agent that can read information presents one level of risk. An agent that can modify systems, communicate externally, spend money, delete data, or delegate authority presents a fundamentally different reliability requirement.

AI agent reliability engineering therefore ensures that increasing capability is accompanied by increasing controls, measurement, observability, containment, and accountability.

How is ARE different from SRE?

Site Reliability Engineering (SRE) applies engineering practices to make software services and distributed systems reliable. Agent Reliability Engineering (ARE) applies similar engineering principles to autonomous systems whose behavior includes probabilistic decision-making, dynamic tool use, delegation, changing context, and potentially expanding authority.

SRE primarily asks whether a system remains available, performant, and dependable under operational conditions. ARE additionally asks whether an autonomous agent behaves within its intended authority, follows enforceable policies, remains observable and reconstructible, contains failures, and can safely gain or lose autonomy as its measured reliability changes.

ARE does not replace SRE. Production AI agents require both. SRE governs the reliability of the systems on which agents operate; ARE governs the reliability of the autonomous behavior occurring within those systems.

How does Agent Reliability Engineering relate to AI safety, AI security, governance, and evaluation?

Agent Reliability Engineering (ARE) is complementary to AI safety, AI security, AI governance, and AI evaluation. It does not replace these disciplines. Instead, ARE provides an engineering discipline for integrating their relevant controls and practices into the reliable operation of autonomous AI systems.

• AI Safety focuses on preventing or reducing harmful outcomes from AI systems.
• AI Security focuses on protecting models, agents, data, tools, infrastructure, and systems from attacks, misuse, compromise, and unauthorized access.
• AI Governance focuses on organizational policies, accountability, risk management, compliance, and oversight.
• AI Evaluation focuses on measuring and testing model and agent behavior against defined criteria.
• Agent Reliability Engineering (ARE) focuses on engineering autonomous AI systems so that reliability, authority, safety, security, governance, evaluation, observability, containment, and recovery operate together as an enforceable production system.

The distinction is one of discipline and integration. Safety, security, governance, and evaluation each address important aspects of autonomous AI. ARE connects these concerns to the engineering lifecycle and runtime controls required to make an agent's behavior measurable, bounded, observable, recoverable, and accountable in production.

ARE therefore does not claim ownership of every reliability-related practice. It provides a framework for ensuring that the relevant practices work together as an autonomous system gains capability, authority, and autonomy.

What is a Reliability Surface?

The Reliability Surface is the set of dimensions and engineering controls that determine how reliably an autonomous AI agent behaves under realistic operating conditions.

ARE considers reliability across both behavioral dimensions and engineering controls.

Behavioral reliability includes dimensions such as:

• Consistency — whether an agent produces stable outcomes and execution trajectories under comparable conditions.
• Robustness — whether an agent continues to behave appropriately when inputs, tools, environments, or conditions change.
• Predictability — whether the likelihood and characteristics of agent behavior can be measured and understood.
• Safety — whether the agent remains within acceptable behavioral, policy, and harm boundaries.

The engineering Reliability Surface includes the controls used to produce and maintain those properties, including:

Identity → Authority → Contracts → Policy → Evaluation → Testing → Runtime Controls → Observability → Governance → Continuous Improvement

The Reliability Surface therefore encompasses both what reliability looks like and the engineering mechanisms used to create it.

What is Reliability Debt?

Reliability Debt is the accumulated risk created when an autonomous system's capabilities, complexity, or authority grow faster than its reliability engineering.

Reliability Debt accumulates when agents gain new tools, models, workflows, integrations, autonomy, or delegation rights without corresponding improvements in contracts, policy enforcement, evaluation, testing, observability, containment, recovery, and governance.

Like technical debt, Reliability Debt is often invisible while a system is growing. Unlike technical debt, its primary cost is not slower feature development. Its primary cost is unpredictable autonomous behavior, increasing operational risk, loss of trust, and reduced ability to safely expand autonomy.

What is Progressive Autonomy?

Progressive Autonomy is the principle that an AI agent should earn greater operational authority as its measured reliability improves and automatically lose authority when reliability deteriorates.

Rather than treating autonomy as a binary property, ARE treats it as a controlled spectrum. An agent may begin with observation or drafting authority and progressively receive additional capabilities, tools, budgets, users, environments, or execution rights as it demonstrates reliable behavior.

Progressive Autonomy creates a continuous feedback loop:

Capability → Evaluation → Reliability → Authority → Monitoring → Re-evaluation

The objective is not to maximize autonomy. The objective is to maximize safe, justified autonomy.

How do you measure AI agent reliability?

AI agent reliability should be measured across multiple dimensions rather than inferred from task success alone.

Behavioral reliability can be evaluated through measures of:

• consistency of outcomes and execution trajectories
• robustness to failures, environmental changes, and input perturbations
• predictability and calibration of decisions
• policy compliance and safety outcomes

Operational and governance reliability should also be measured through indicators such as:

• policy violation rate
• authority exception rate
• human intervention rate
• failure and recovery rate
• evaluation coverage
• control and policy coverage
• observability completeness
• incident frequency and severity
• blast radius of failures
• authority-lineage coverage
• successful recovery and rollback rates
• reliability drift over time

A reliable agent is therefore not simply one that succeeds frequently. It is one whose behavior, authority, failures, and recovery remain within defined and measurable boundaries.

How do you govern AI agents?

AI agents should be governed through explicit, enforceable controls that exist outside the agent's own instructions.

ARE governance begins with:

1. Identity — establish which agent or workload is acting.
2. Authority — explicitly define what the agent is permitted to do.
3. Contracts — define expected behavior, inputs, outputs, dependencies, and side effects.
4. Policy — enforce organizational, security, regulatory, and operational constraints.
5. Evaluation — continuously measure whether the agent behaves as intended.
6. Runtime controls — constrain execution through budgets, circuit breakers, isolation, and halt mechanisms.
7. Observability — record consequential actions and sufficient context to reconstruct what occurred.
8. Governance — continuously validate that controls remain aligned as the agent, environment, and authority change.

The agent should not be the sole enforcement point for the rules governing its own behavior. Critical constraints must be independently enforceable.

How do you safely increase AI agent autonomy?

AI agent autonomy should increase through measured progression rather than unrestricted capability expansion.

A practical progression is:

Observe → Draft → Act with Approval → Act Within Defined Scope → Expanded Authority

At each stage, reliability should be evaluated against the risks associated with the additional authority. Increased autonomy may require stronger evidence of consistency, robustness, policy compliance, recovery behavior, and operational stability.

Autonomy should also be reversible. When reliability deteriorates, controls should automatically reduce the agent's authority, restrict capabilities, increase approval requirements, or return the agent to a lower autonomy level.

Safe autonomy is therefore earned, bounded, observable, and reversible.

What controls should production AI agents have?

Production AI agents should have controls appropriate to their capabilities, authority, risk, and operating environment. At minimum, consequential agents should provide:

1. Distinct identity so actions can be attributed to a specific agent or workload.
2. Explicit authority defining permitted tools, resources, actions, data, and scope.
3. Least privilege so agents receive only the authority required for their tasks.
4. Enforceable policy outside the model or agent instructions where appropriate.
5. Contracts and validation defining expected inputs, outputs, side effects, and constraints.
6. Continuous evaluation and testing to detect behavioral failures, regressions, and drift.
7. Runtime containment including execution budgets, rate limits, circuit breakers, isolation, and halt mechanisms.
8. Approval gates for consequential or irreversible actions where required by risk.
9. Observability sufficient to reconstruct consequential actions, decisions, tool calls, and authority.
10. Recovery mechanisms including retry, rollback, compensation, replay, or controlled termination as appropriate.
11. Authority lineage for delegated or multi-agent execution.
12. Continuous governance that evaluates whether the agent's policies and authority remain appropriate as its capabilities and environment change.

The appropriate controls vary by risk. The principle is constant: the greater the capability and authority of an autonomous agent, the greater the reliability evidence and independent controls required to operate it safely.

The ARE Objective

Agent Reliability Engineering does not seek to eliminate autonomy or eliminate failure. It seeks to make autonomous behavior measurable, bounded, observable, recoverable, and accountable.

The goal is not simply to build agents that can do more.

The goal is to build agents that can safely be trusted to do more.

Agent Reliability Engineering Terminology

Agent Reliability Engineering (ARE) uses a common vocabulary to describe the properties, risks, controls, and operating principles required to make AI agents reliable in production.

Agent Reliability Engineering (ARE)

Agent Reliability Engineering (ARE) is a software engineering discipline for making AI agents reliable, governable, observable, recoverable, and accountable in production. ARE treats reliability as an architectural property rather than a runtime afterthought.

AI Agent Reliability

AI agent reliability is the degree to which an autonomous AI agent consistently behaves as intended, operates within its authorized scope, remains resilient under expected and adverse conditions, and can be observed, contained, and recovered when failures occur.

Reliability Surface

Reliability Surface is the multidimensional set of behavioral properties and engineering controls that determine how reliably an autonomous AI agent operates under realistic conditions.

ARE considers behavioral dimensions including consistency, robustness, predictability, and safety, together with engineering controls spanning identity, authority, contracts, policy, evaluation, testing, runtime controls, observability, governance, and continuous improvement.

Reliability Debt

Reliability Debt is the accumulated risk created when an autonomous system's capabilities, complexity, or authority grow faster than its reliability engineering.

Like technical debt, it represents deferred engineering work. Unlike technical debt, its primary consequence is unpredictable autonomous behavior, increasing operational risk, loss of trust, and reduced ability to safely expand autonomy.

Progressive Autonomy

Progressive Autonomy is the principle that an AI agent earns greater operational authority as its measured reliability improves and automatically loses authority when reliability deteriorates.

The objective is not maximum autonomy, but safe, justified, and reversible autonomy.

Agent Authority

Agent Authority is the explicitly defined and enforceable scope of actions an AI agent is permitted to perform, including permitted tools, resources, data, systems, financial limits, delegation rights, approval requirements, and prohibited or irreversible actions.

An agent's capability to perform an action does not by itself establish that the agent is authorized to perform it.

Agent Governance

Agent Governance is the system of policies, controls, processes, and evidence used to ensure that an AI agent operates within its intended identity, authority, behavioral requirements, risk boundaries, and organizational obligations.

Agent Reliability Controls

Agent Reliability Controls are the technical and operational mechanisms used to keep an autonomous AI agent's behavior within defined reliability, authority, safety, and recovery boundaries.

Examples include identity, least privilege, contracts, policy enforcement, sandboxing, approval gates, execution budgets, circuit breakers, kill switches, continuous evaluation, observability, audit trails, and recovery mechanisms.

Reliability Maturity

Reliability Maturity is the degree to which an autonomous AI system has implemented, validated, and continuously improved the engineering capabilities required for reliable operation.

Reliability maturity progresses from unmanaged autonomous behavior toward systems capable of continuously measuring reliability and adapting controls as conditions and risks change.

How These Concepts Relate

These concepts form a connected model:

Agent Reliability Engineering is the discipline.

AI Agent Reliability is the property being engineered and measured.

Reliability Surface describes the dimensions and controls that influence that property.

Reliability Debt describes the risk created when capability and autonomy outpace reliability engineering.

Progressive Autonomy governs how authority expands or contracts based on demonstrated reliability.

Agent Authority defines what an agent is permitted to do.

Agent Governance coordinates the policies, controls, accountability, and evidence surrounding that authority.

Agent Reliability Controls provide the mechanisms that enforce reliability and authority boundaries.

Reliability Maturity describes how effectively these capabilities have been implemented and continuously improved.

The Problem

Reliability, not intelligence, is now the adoption bottleneck for AI agents.

The next decade will not be won by the smartest agents.
It will be won by the most reliable ones.

Key Statistics

• 86% of enterprises have deployed agents. Only 34% trust them¹.
• 40% are expected to demote or decommission autonomous agents².

North Star of Agent Reliability Engineering

Without reliability, you only have liability.

Embrace reliability. Earn trust. Enable adoption.

The next decade will not be won by the smartest agents —
it will be won by the most reliable ones.

Core Definitions

Agent Reliability Engineering (ARE)
The engineering discipline responsible for making autonomous AI agents predictable, governable, recoverable, and accountable in production. It treats reliability as a first-class architectural concern rather than a runtime afterthought.

Reliability Surface
The multi-dimensional behavioral profile of an AI agent under realistic conditions. It includes consistency, robustness, predictability, and safety — independent of raw task success rate.

Reliability Debt
The accumulated risk created when an agent’s capabilities grow faster than its reliability engineering. Like technical debt, it compounds. Unlike technical debt, its primary cost is unpredictable autonomous behavior and loss of trust.

Progressive Autonomy
The principle that agents should earn greater operational authority (e.g. budget and user cohorts) only as their measured reliability improves, and automatically lose authority when reliability drifts.

Table of Contents

1. The Inflection
2. Intelligence Is No Longer Enough
3. Related Work
4. Reliability Surface
5. The Smartest Intern
6. From Intelligence to Adoption
7. Agent Reliability Engineering (ARE)
8. The ARE Surface
9. Reliability Debt
10. Why It Matters
11. Sources of Reliability Debt
12. Symptoms
13. Reliability Debt Interest
14. Engineering Principle
15. The Meaning and Controls Behind the Words
16. The Principles of Agent Reliability Engineering
17. Reliability Maturity Model
18. The ARE Toolbox
19. The ARE Knowledge Graph
20. Call to Action
21. The Next Discipline

1. The Inflection

Every major shift in computing has required a new engineering discipline.

Mainframes created operations. Distributed systems demanded a new discipline; Google formalized it as Site Reliability Engineering. Cloud created Platform Engineering. Containers created a new operational model around Kubernetes.

Now software has begun to perform tasks. Agents no longer simply answer questions. They make decisions, call APIs, write code, move money, coordinate systems, and operate inside regulated environments with very real consequences. And their velocity demands automated compliance and governance.

We have spent years making agents more intelligent. We have spent comparatively little time making them reliable. That gap is becoming the defining engineering challenge of the next decade.

Enterprise evidence already shows the cost. Roughly half of enterprises that shipped agents based on internal evaluations later experienced customer-facing failures.³ Two-thirds of organizations that have deployed agents do not trust the actions those agents take. Adoption has raced ahead of reliability, exposing companies to liability.

2. Intelligence Is No Longer Enough

For the past several years, the industry has optimized almost exclusively for intelligence: larger models, better benchmarks, more capable reasoning, more tools, and more autonomy. That strategy worked while AI primarily answered questions. It breaks down once software begins taking action. An intelligent agent that cannot be trusted becomes an operational liability. The next generation of engineering must optimize for a different objective: reliable autonomous behavior.

3. Related Work

The term “Agent Reliability Engineering” and the core claim that reliability, not intelligence, is the primary bottleneck already appear in scattered places: Karpathy’s “march of nines”⁴ framing of production reliability, Gartner’s prediction that >40% of agentic AI projects will be canceled by end of 2027⁵, practitioner blogs and role definitions, academic efforts such as “Towards a Science of AI Agent Reliability”⁶, and commercial offerings such as Galileo’s Agent Reliability Platform⁷.

None of these, however, formalize ARE as a coherent engineering discipline with explicit principles, practices, and a call to build in the open. This document is the first manifesto that attempts to do so.

4. Reliability Surface

We define the reliability surface of an AI agent as its multi-dimensional behavioral profile under realistic conditions, independent of raw task success rate. Following Rabanser et al., it comprises four dimensions and twelve metrics:

• Consistency: outcome, trajectory (distributional + sequential), and resource consistency
• Robustness: fault tolerance, environmental robustness, and prompt/input perturbation robustness
• Predictability: calibration, discrimination, and Brier score
• Safety: policy compliance and harm severity

Leaders should fund visibility into this surface, not just accuracy, before production deployment.

5. The Smartest Intern

Imagine hiring an exceptionally smart intern. They understand everything immediately. They write elegant code. They surprise the team with insight.

But they only finish about half the work they start. Their consistency declines as projects grow more complex. The larger the team, the more their performance drifts. And when something goes wrong, no one can fully reconstruct why they made a particular decision.

Would you let that intern deploy directly into production, move money, or act inside a regulated system without oversight? Of course not. You would capitalize on their raw intelligence by providing supervision, defining their authority, reviewing their work and gradually increasing their responsibility as their performance, and your trust in them, grows.

Agent Reliability Engineering applies the same principles to intelligent software. The problem is not intelligence. The problem is reliability.

6. From Intelligence to Adoption

Every investment in AI ultimately succeeds or fails at one of these transitions. Every agent shipped on the allure of raw intelligence and capability alone, skipping reliability and therefore trust, begins life in debt, Reliability Debt.

OpenClaw took the world by storm because it combined intelligence (models) with the capability to act, making it a hobbyist dream come true. However, its initial weakness in reliability, in both security and governance, undermined early enterprise trust and adoption.⁸

Every generation of AI has focused on increasing intelligence. The next generation must focus on increasing reliability. Without it, capability never converts into sustained trust or adoption.

7. Agent Reliability Engineering (ARE)

Agent Reliability Engineering (ARE) is the engineering discipline responsible for making AI agents predictable, governable, recoverable, and accountable in production. ARE achieves this through explicit identity, authority, contracts, policy enforcement, evaluation, runtime controls, observability, governance, and continuous improvement. Just as SRE transformed operations into engineering, ARE transforms trust in autonomous systems into an engineering problem that can be measured, designed, and continuously improved.

ARE is not another framework, runtime, security product, or evaluation tool. It is the discipline that makes an agent's authority verifiable, its actions observable, and its failures recoverable, before it ever touches production.

It follows the same logic that made Site Reliability Engineering effective. SRE did not eliminate failure; it made failure observable, bounded, and recoverable. ARE does the same for agents that can act. It accepts that probabilistic systems will vary and that errors can compound across steps, tools, and learning loops. The discipline exists to keep those variations within acceptable bounds, to make failures visible, and to ensure the system can recover without losing control or visibility.

Research already shows the divergence: capability scores have risen far faster than consistency, robustness, predictability, and safety.⁹ Industry investments in Forward Deployed Engineering, policy-enforcing sandboxes, and governed execution confirm that the problem is now recognized at scale.¹⁰

8. The ARE Surface

Agent Reliability Engineering spans the complete lifecycle required to transform autonomous capability into trustworthy production systems. It is not a single product, framework, runtime, or policy engine. It is the combined effect of every control that determines whether an autonomous system behaves as intended. We call this the Reliability Surface. It includes: identity, authority, contracts, policy, evaluation, testing, runtime controls, observability, governance, continuous evaluation, continuous improvement. These capabilities work together to transform intelligence into reliability, which then builds trust.

Reliability Surface has two related meanings in ARE:

1. Behavioral Reliability Surface — the measurable behavioral profile of an agent across consistency, robustness, predictability, and safety.
2. Engineering Reliability Surface — the set of architectural controls that influence that behavior, including identity, authority, contracts, policy, evaluation, testing, runtime controls, observability, and governance.

Academic research measures reliability through dimensions such as consistency, robustness, predictability, and safety. ARE defines the engineering capabilities required to continuously improve those dimensions.

The Reliability Surface spans the entire engineering lifecycle, from design through continuous improvement, transforming autonomous capability into trustworthy production systems.

9. Reliability Debt

Reliability Debt is the accumulated risk created when an autonomous system’s capabilities grow faster than its reliability engineering. Like Technical Debt, it represents deferred engineering work. Unlike Technical Debt, its primary consequence is not slower feature delivery, it is unpredictable autonomous behavior in production.

Reliability Debt accumulates whenever an agent is permitted to act without sufficient contracts, enforceable policy, evaluation coverage, observability, recovery mechanisms, or runtime controls. As autonomy increases, the debt compounds. Left unaddressed, it becomes the primary barrier to safely scaling agentic systems. Reliability Debt is the cause behind the North Star phrase: “Without reliability, you only have liability.”

10. Why it matters

Every new capability expands the Reliability Surface:

• a new tool
• a new model
• a new workflow
• a new sub-agent
• a new integration

Organizations routinely invest in expanding what agents can do, expanding the Reliability Surface, while failing to invest in Reliability Engineering, thereby creating Reliability Debt. Just as Technical Debt eventually slows software delivery, Reliability Debt eventually limits the safe expansion of autonomy.

11. Sources of Reliability Debt

Common sources include:

• Missing or ambiguous contracts
• Implicit rather than explicit authority
• Policy that lives only in prompts
• Insufficient evaluation and adversarial testing
• Incomplete decision traces and limited observability
• Absent runtime controls (budgets, circuit breakers, kill switches)
• Unmanaged state and missing recovery paths
• Static governance that never tightens with experience

12. Symptoms

Reliability Debt usually surfaces before catastrophic failure:

• rising policy violations and authority exceptions
• increasing manual intervention
• growing incident volume and investigation time
• expanding prompt complexity
• difficulty reproducing or explaining decisions
• drift between expected and observed behavior

These are early indicators that reliability engineering has fallen behind capability growth.

13. Reliability Debt Interest

Reliability Debt Interest is the ongoing operational cost incurred because the debt has not been paid down. Examples include:

• more human approvals and slower deployments
• higher cloud and API spend from unconstrained retries
• longer incident investigations
• frequent policy exceptions
• customer-facing failures
• declining organizational confidence in autonomous operation

Technical Debt costs engineering time. Reliability Debt costs organizational trust.

14. Engineering Principle

Every new autonomous capability introduces potential Reliability Debt.

The purpose of Agent Reliability Engineering is not to slow innovation; it is to ensure that reliability engineering grows at least as quickly as capability. Organizations that continuously reduce Reliability Debt can safely expand autonomy. Organizations that ignore it eventually discover that their greatest limitation is no longer model intelligence, it is operational reliability.

15. The Meaning and Controls Behind the Words

Each capability answers an engineering question and a business question. The engineering question is what your team asks. The business question is what your leadership, customers, and regulators will ask. The controls are the engineering tools that deliver reliability.

16. The Principles of Agent Reliability Engineering

These principles define the discipline. They turn reliability from an afterthought into an architectural property of systems that must operate across fluid stacks, evolving knowledge, and short-lived agents.

1. Governance is architectural, not operational.

Identity, authority, and proof must exist before the first action. Accountability cannot be retrofitted after the first incident. Governance that begins only at runtime has already failed.

2. Authority must be explicit, verifiable, and earned.

Every autonomous action must be traceable to explicit authority. Agents may delegate tasks and authority, but accountability must remain traceable through the chain of execution.

3. Agents earn their operational authority through progressive autonomy.

Agents earn greater operational authority only as their measured reliability surface improves, and automatically lose authority when reliability drifts.

4. Constraints must be independently enforceable.

An agent cannot be trusted to enforce its own limits. Constraints must be enforced independently so compromise, prompt injection, or behavioral drift cannot silently remove them.

5. Agents should never rely on implicit assumptions.

Reliable systems make expectations explicit. Contracts define inputs, outputs, authority, constraints, side effects, dependencies, and expected behavior. Ambiguity is the enemy of reliability.

6. Governance must operate at agent speed.

Ephemeral agents and sub-agents that may live only milliseconds make purely hand-coded policy impossible to scale. Agents may be created, delegated, and retired faster than humans can review or approve them. Governance must therefore execute automatically, producing and enforcing controls at the pace autonomous systems operate.

7. Behavior must be governed consistently across the stack.

Contracts express expected behavior, while policies enforce it across models, tools, sandboxes, networks, and infrastructure. These layers must remain aligned so the system behaves consistently from end to end.

8. Reliability is engineered, not observed.

Reliability cannot be inferred from successful demonstrations. It is engineered through explicit controls, continuous measurement, bounded failure, and systematic improvement. Reliability is both a measurable property and an engineering discipline.

9. Every consequential action must be observable and reconstructible.

Every consequential decision must leave a complete, immutable trail sufficient to explain what happened, why it happened, and under whose authority it occurred.

10. Failure must be contained, recoverable, and improvable by design.

Circuit breakers, budgets, halt semantics, and progressive autonomy keep probabilistic error from compounding. Autonomous systems must minimize blast radius, recover predictably, and continuously reduce the likelihood of repeated failure.

11. Reliability begins before deployment.

Reliability is not established by a successful deployment or passing an evaluation. It is engineered from the earliest stages of development and runtime observability strengthens it but does not replace it. The most reliable autonomous systems are engineered for reliability long before they execute their first action.

17. Reliability Maturity Model

Modeled loosely on the leveled, per-capability structure of frameworks like SLSA in software supply chain security, this maturity model lets organizations assess reliability incrementally rather than as a pass/fail gate.

Level 1 — Unmanaged

Agents run with human-equivalent or shared credentials. No distinct identity. The agent enforces its own constraints via prompt instructions only — nothing external checks it. Logging is incidental, not designed for reconstruction. No containment: a failure has no defined blast radius.

Signals

• You cannot reliably answer “which specific agent took this action?” after the fact
• There is no independent mechanism that can stop an agent once it has started acting

Level 2 — Observed

Agents have distinct identities, but no verified authority lineage; you know which agent acted, not what it was actually allowed to do. Policy exists as a document, not an enforced boundary. Basic action logs exist but aren't immutable or complete enough to reconstruct a decision. A human can pull the plug manually; there's no automatic circuit breaker.

Signals

• You can identify the agent, but you cannot prove what it was actually authorized to do
• Stopping a misbehaving agent still requires a human to notice and intervene

Privacy Note
Complete, immutable decision trails create an inherent tension with privacy regulations such as GDPR’s right to erasure. ARE does not require perpetual, unredacted retention of every prompt, retrieval, or intermediate state. Production systems must pair observability with retention policies, selective redaction, and purpose limitation so that reconstruction remains possible for accountability while personal data can still be deleted or minimized when required by law. The goal is auditable reliability, not permanent surveillance.

Level 3 — Governed

Every agent has a verifiable identity, and authority is explicitly scoped per task. Policy enforcement lives outside the agent (gateway, sandbox, or proxy — not the model itself). Full decision trails exist: prompts, tool calls, responses, retrievals, timestamped and preserved. Circuit breakers and budgets are defined per agent class, and failures halt automatically rather than propagating. Reliability metrics are tracked and reviewed on a cadence.

Signals

• An external system (not the model) can independently block or halt agent actions
• You can reconstruct most consequential decisions well enough to explain them to a customer or auditor

Level 4 — Accountable

Sub-agents inherit and can prove their authority lineage back through the spawn chain — not just “an agent did this” but “this specific agent, spawned by this parent, with this scope, did this.” Policy is generated dynamically from contracts and templates so short-lived sub-agents don't fall outside coverage. Decision trails meet regulatory-grade explainability. Autonomy is progressive; agents earn expanded authority through demonstrated reliability and lose it automatically on drift.

Signals

• You can prove the full authority chain for any sub-agent action back to the original task
• Agents automatically gain or lose scope based on measured reliability, not just static configuration

Level 5 — Adaptive

Full spawn-chain authority verification holds even for sub-agents that live milliseconds. Policy generation keeps pace with agent evolution in real time — no human is the bottleneck. The reliability surface feeds back into policy generation automatically, so the system tightens itself after incidents rather than waiting for a human postmortem. Critically, the tooling is usable by non-specialists, so reliability isn't gated behind a small team who understands the internals.

Signals

• New or short-lived agents receive appropriate policy without manual rule-writing
• Reliability problems detected in production automatically tighten future controls
• People who are not reliability specialists can still understand and adjust the system's behavior

ARE is not about slowing agents down. It is about making them trustworthy enough to move fast.

18. The ARE Toolbox

19. The ARE Knowledge Graph

Agent Reliability Engineering
│
├── AI Agent Reliability
│ ├── Consistency
│ ├── Robustness
│ ├── Predictability
│ └── Safety
│
├── Reliability Surface
│ ├── Identity
│ ├── Authority
│ ├── Contracts
│ ├── Policy
│ ├── Evaluation
│ ├── Testing
│ ├── Runtime Controls
│ ├── Observability
│ └── Governance
│
├── Reliability Debt
│ ├── Sources
│ ├── Symptoms
│ └── Interest
│
└── Progressive Autonomy
├── Measurement
├── Authority
├── Expansion
└── Contraction

20. Call to Action

Treat governance as a design primitive. Identity, authority, contracts, and reconstructible trails must be present from the first action. Adopt shared tenets, contribute patterns, and insist that both the policy governing the agent and the infrastructure policies governing its stack are explicit, enforceable, and reviewable.

This discipline does not belong to one company. It belongs to everyone building AI Agents. Agent Reliability Engineering will only succeed if it is developed in the open, with shared vocabulary, portable approaches, and common reliability surfaces emerging through collective practice. This discipline, like this document, will evolve with learning and feedback.

21. The Next Discipline

Site Reliability Engineering transformed distributed computing by making complex systems observable, recoverable, and dependable. Agent Reliability Engineering extends that philosophy to autonomous systems.

Intelligence alone is insufficient. Trust must be engineered. Accountability must be architectural. Authority must be earned. Reliability must become continuous.

As AI agents become foundational to every industry, reliability will become as indispensable to agents as SRE became to cloud infrastructure.

This is not the end of software engineering.

It is the beginning of its next discipline.

The future will belong not simply to intelligent agents —

but to reliable ones.