NEWS

Architecture separates reasoning and execution for AI agents in critical operations

Architecture separates reasoning and execution for AI agents in critical operations
Image: Redação iMasters
News
Reading
6 min
Code
1
In short

An architecture pattern described by InfoQ shows how operations platforms in regulated industries let the model propose actions, but never execute them without passing through a policy gateway outside the AI's control.

The problem: too much signal, too little correlation

Utility operations teams (energy, water, sanitation) already have more data than they can process manually: application logs, infrastructure metrics, API telemetry, security events, job failures and service desk tickets describe the same environment, but arrive fragmented across separate tools. An article published on InfoQ on November 16, 2026, written by Purnang Borah and reviewed by Rafał Gancarz, describes the architecture used in an agentic operations platform in this type of regulated environment.

The article's starting point is direct: agentic AI is appealing because it can reason over fragmented evidence, retrieve operational knowledge and coordinate multi-step work. But a utility cannot treat an agent the way it treats a conversational assistant. A wrong summary is inconvenient; a wrong action in production can affect a customer-facing service, a safety workflow, a regulatory report or a system involved in reliable power delivery.

The pattern: a control plane separates reasoning from execution

The organizing idea, according to the article, is what it calls an AI control plane, a term borrowed from networking and cloud infrastructure: one plane decides what should happen, a separate plane executes it. In the reasoning plane, the orchestrator and domain agents analyze events, retrieve context, compare the incident with historical patterns, estimate business impact and propose remediation. None of these components has the authority to directly change a production system.

Diagram shows the reasoning plane (agents, RAG, LLM) connected to the execution plane (tool gateway, APIs) through a risk classifier and deterministic policy gate, with human approval for high-risk actions
Diagram shows the reasoning plane (agents, RAG, LLM) connected to the execution plane (tool gateway, APIs) through a risk classifier and deterministic policy gate, with human approval for high-risk actions. Reprodução: infoq.com.

A proposed action only crosses into the execution plane through a deterministic policy gate and a governed tool gateway. The gate decides whether the action is allowed and what approval it requires; the gateway applies the final authorization, obtains scoped credentials, invokes the target system and logs the result. This separation changes the cost of an error: a root cause hallucinated by a conventional model can turn into a bad action; in this design, it becomes only a bad proposal, which the policy can reject.

The gateway is the only door into production

Each proposed action is mapped, outside the model, to a risk class and an approval requirement defined in a versioned action catalog. In the scenario described by the article, a diagnostic tool is classified as low risk and can run automatically; restarting a stateless component, on the other hand, is mapped to a mandatory human approval rule. The Remediation Agent can propose the restart, but it cannot downgrade its own risk just because it is confident in the answer.

The article is explicit about why the gateway is the only door: if an agent can bypass this barrier, it stops being a governance boundary. That is why the design avoids target-system credentials in the reasoning runtime, uses deny-by-default identity policies, restricts network paths and exposes credentials only to the tool implementation that actually needs them.

The AWS reference: AgentCore, Cedar and MCP

The reference implementation runs on Amazon Bedrock AgentCore, which provides a managed agent runtime, memory, gateway, identity and observability integrated with Amazon Bedrock for model access and with Bedrock Knowledge Bases for retrieval over the company's runbooks and incident history. AgentCore Policy, generally available since March 2026, covers exactly the boundary the pattern depends on: rules written in natural language or as code are compiled into Cedar, AWS's own open-source authorization language, and attached to an AgentCore Gateway, which evaluates every tool call made by the agent before allowing or denying it.

The article recommends that teams starting today evaluate this component before building their own equivalent, since it delivers deterministic, action-level authorization, enforced at the gateway rather than inside the agent's logic. MCP (Model Context Protocol) is used at the tool boundary to standardize how tools are described and invoked, which gives the platform a single place to restrict operations, validate arguments, enforce policy and log evidence.

The same controls on Azure and Google Cloud

The pattern is not tied to AWS: it requires a managed agent runtime, a retrieval layer and a tool gateway that enforces policy and that agents cannot bypass. On Microsoft Azure, the article points to Microsoft Foundry Agent Service as the runtime, Microsoft Entra for agent identities and Azure AI Search for retrieval, with Azure API Management serving as the tool gateway (some of these governance features are still in preview).

On Google Cloud, the reference is the Gemini Enterprise Agent Platform, with Agent Runtime and Agent Identity, using Agent Gateway to enforce IAM policies and Model Armor to check for prompt injection.

Multiple agents, one action catalog

Instead of a monolithic agent with broad access, the reasoning plane uses a hierarchical structure of multiple agents with narrow responsibility, easier to test and explain. The Orchestrator Agent receives normalized events and routes the work; the Application Reliability Agent analyzes known failures; the Platform Intelligence Agent looks at API failures and dependencies; the Business Impact Agent translates technical state into business consequence; and the Remediation Agent is the only reasoning component authorized to propose an action that touches production, still without authority until it passes through policy and approval.

All agents share context retrieved from a corporate knowledge base: runbooks, SOPs, architecture documentation, incident history and dependency maps. The article is direct about a practical risk in this layer: if a runbook is outdated or contradictory, retrieval will faithfully surface that outdated instruction. That is why every runbook carries a named owner and a last-revision date, returned together with each retrieved passage, and operator rejections that flag a flawed runbook are routed back to the owner for correction.

One event, step by step

The article illustrates the flow with a common integration operations scenario: an API's latency starts to rise, a downstream integration starts retrying more frequently and a processing queue grows, each signal individually below the threshold that would trigger an alert. The ingestion layer normalizes the three signals and preserves the source evidence, as in the article's simplified example:

json
{
  "event_id": "evt-000193",
  "timestamp": "2026-04-12T14:03:27Z",
  "source": "apm",
  "service": "customer-payments-api",
  "environment": "prod",
  "event_type": "latency_degradation",
  "technical_severity": "warning",
  "dependency_ids": ["billing-integration", "payments-queue"],
  "business_service": {
    "name": "Customer bill payment",
    "criticality": "high",
    "mapping_source": "service-catalog"
  }
}

The mapping to the business service comes from the service catalog, it is not inferred by the model: the article insists that basic facts, such as which system emitted the event, are established through deterministic parsing and source adapters, not probabilistic extraction. The orchestrator recognizes the shared dependency chain and triggers the domain agents, which produce a structured operational hypothesis with a likely failure mode, supporting evidence and remediation options documented in the runbook.

Autonomy that is earned (and revoked)

According to the article, the platform starts read-only and expands one action class at a time, guided by the quality of the recommendations, the operator's acceptance rate, execution outcomes and rollback safety. This autonomy can be revoked as easily as it is granted, which the text treats as a deliberate part of the architecture, not as a limitation to hide.

For architects building systems in Brazil in regulated industries (energy, telecom, healthcare, financial services), the value of the pattern is not in any single piece, but in where the authority boundary is drawn: outside the model, versioned, testable before deployment and with complete evidence attached to a single point of passage. The original article goes on, in later sections not covered here, to describe how prediction enters the design without gaining execution authority, which leaves room to explore that specific point in another piece.

Translated from the Brazilian Portuguese original · Read the original