Putting Agentic AI on AWS and Azure
Two provider-specific maps show where managed agent services help, where controls still need to be assembled, and what to test before a tool changes a business record.
Written as at 29 October 2026.
agentic-aicloud-architectureawsazureidentityai-governance
The enterprise problem is the gap between a proposal and an effect
An agent diagram can show a model, tools, memory, security and a human approval step. The enterprise question is whether those controls decide every path that can change a live record. If the agent can call a side API directly, or an approval survives a changed payload, the boxes do not describe the effective control boundary.
Provider diagrams do not show the whole enforcement path
The LinkedIn image names real AWS components: Amazon Bedrock, AgentCore Runtime, AgentCore Gateway, memory, knowledge search, Lambda tools and observability. It is more than a vendor-neutral sketch, but it remains conceptual rather than a deployment recipe. It does not show which identity reaches each tool, exactly where policy is evaluated, or which system is authoritative when a business action commits.
AWS documents separate model access, tools and knowledge services, with security and observability spanning the architecture. AgentCore adds managed runtime, identity, gateway, memory and observability components. Policy in AgentCore associates deterministic Cedar policies with AgentCore Gateways and evaluates applicable policies on tool requests. For supported MCP tool calls through that Gateway, policy can evaluate the principal, action, resource, input and, where configured, session context. The documented default is deny when no applicable permit exists, with forbid taking precedence.
That scope matters: the AWS documentation does not mean every AWS API call, Lambda invocation or direct path is automatically mediated by this policy engine. Teams must map every route from agent code to tools and protect routes outside the Gateway separately. IAM roles, resource policies, network boundaries and application checks still need correct scope.
Microsoft Foundry Agent Service documents a managed agent runtime, tool connections, identity and security features, and tracing with Application Insights. Microsoft Entra agent identities can represent an agent at downstream resources. Depending on the design, a call can use the agent’s own application permissions or delegated access for an authenticated user. Azure RBAC, service-specific data roles or the API’s own policy determine what that identity can do.
Microsoft’s agent framework supports approval-required function tools that pause a run and return an approval request to the caller. The application must collect the decision, associate it with the proposed action, and resume or reject the run. Agent identity authenticates the agent; it does not automatically grant or constrain every resource. Scope permissions narrowly and verify feature availability in the target region and deployment mode.
The CAE interpretation keeps the decision outside the model
The shared structure is a proposal flowing through an independent decision point before it reaches a system of record. The Commit Boundary, a CAE construct, is the point where a proposal would become an externally observable effect. The model can interpret context and propose a tool call. Deterministic controls validate the principal, action, resource, input, current policy and business state; the receiving service decides whether its own transaction can commit.
The provider mechanisms differ. AgentCore Policy is a policy engine associated with AgentCore Gateway and covers the mediated calls it evaluates. Microsoft Foundry provides agent hosting and identity integrations; authorization is distributed across Entra, Azure RBAC and downstream services, with an application or gateway often supplying a business-specific check. These are not feature-for-feature equivalents, nor do they replace the organisation’s authority model.
Use five tests before scaling a consequential workflow
Use these checks before treating either arrangement as ready for production:
- Enumerate paths. Trace every route from the agent runtime to data and tools. Include direct SDK calls, alternate gateways, background jobs and human-operated recovery paths.
- Test authority at execution. Revoke a permission after planning but before the tool call. The action should be denied at the enforced boundary, with an attributable reason.
- Change the approved payload. Alter the target or amount after approval. The prior approval should no longer authorise the changed request.
- Exercise partial failure. Let the business service commit but drop the response. Recovery should reconcile state or use idempotency rather than repeat a non-idempotent side effect.
- Reconstruct the result. A reviewer should be able to connect caller, agent, context provenance, tool request, policy decision, approval, system-of-record outcome and trace without treating the model’s explanation as the evidence.
The failure modes hide in the seams
Illustrative scenario: fictional, not a real organisation or outcome. A purchasing agent proposes changing a supplier’s bank details. A human approves a specific supplier and account change. Before execution, the action service verifies the supplier record is unchanged, the approval remains valid, the actor still has authority and no conflicting update occurred. If any value changed, it stops and asks for a fresh decision. After execution, the supplier system returns the authoritative result and a durable record links the proposal, approval, policy decision and committed change.
A dashboard can show a tool call; a policy can block one route; an approval screen can capture a click. A missing identity context, unmediated API, stale approval or repeated side effect can still defeat the intended control. The architecture is only as strong as the weakest path that can produce the effect.
Executives, architects and engineers have different work
Executives: assign an accountable owner for the business outcome, exception handling and recovery before authorising a tool to change a live record.
Architects: choose the provider components after defining identity propagation, policy scope, commit authority and evidence retention. Mark which controls are native, configured, custom-built or still absent.
Engineers: test the deny path, approval binding, changed-state path, direct-call bypasses and duplicate-side-effect recovery in the same release pipeline as the agent.
Two provider maps make the seams visible
Key takeaways
- The LinkedIn diagram names meaningful AWS components but leaves identity propagation and the full action-enforcement path implicit.
- AgentCore Policy documents enforcement for MCP tool invocations through its Gateway; direct routes need separately designed controls.
- Microsoft Foundry agent identity authenticates the agent, while Azure RBAC and downstream services govern its access.
- Human approval should be bound to the exact action and rechecked before a consequential commit.
- The system of record, not the model’s narration or a successful orchestration step, determines whether a business change occurred.
Sources and further reading
The AWS and Microsoft references in the front matter describe specific product behaviour. Capabilities, names and regional availability can change; check the linked documentation and target-region service limits during design. These original diagrams illustrate possible arrangements; they are not vendor reference architectures or endorsements.
Apply the map to one consequential workflow
Choose one action, such as approving a supplier change, and trace its identity, context, tool route, policy decision, human approval, commit and recovery evidence. That exercise will show where an AWS or Azure service covers the control and where the application still owns it.
The architecture should also be measured against the business outcome, not the number of successful tool calls. For a supplier change, the useful unit might be a correctly completed and verified change. Count the ordinary path, clarification work, rejected requests, duplicate attempts, human review and recovery from an uncertain response. A fast agent call can still leave a case unfinished or create rework elsewhere in the process.
Keep the baseline and the agent-assisted path on the same definition of completion. Record elapsed time, exception rate, correction work and the share of cases that require human intervention, then check those measures against the authoritative supplier record. These are evaluation questions for a specific organisation, not results claimed for either provider. They help decide whether the managed components remove a real bottleneck or simply move effort to a different team.
Application requires organisation-specific architecture, security, privacy, legal, regulatory, operational, safety, accessibility, commercial and governance review, together with appropriate approvals.
This article is part of CAE Field Notes, a series accompanying the book The Contextual Agentic Enterprise.
Related
When an AI Stack Becomes an Action
A component stack tells you what runs. Follow one proposed action through context, authority, commitment and evidence to learn whether the system can act responsibly.
From Agentic AI to the Contextual Agentic Enterprise: How the Components Work Together
A research article on how business ownership, identity, knowledge, context assembly, agents, orchestration, policy, operational systems, evidence and improvement interact, followed through one fictional claim, the Commit Boundary, an uncertain response and a governed improvement loop. CAE is the author's proposed synthesis, distinct from Agentic Context Engineering (ACE).
What Survives a Model Swap: Keeping the Shell, Replaying the Decisions
Models behind an agent are retired on published schedules, and a newer one does not behave like the old one. This note sorts an estate into what carries over, what is re-tested, what is rebuilt and what is rented, and shows how to replay past decisions through a new core before cutover. Includes a fictional example, an original animated diagram and a companion simulator with invented numbers.