Part 4 of the series "The Enterprise AI Vendor Landscape"
Bedrock AgentCore and Amazon's Bet on Being the Foundation, Not the Agent
The Infrastructure Bet
Microsoft is selling the governance layer. Salesforce is selling the agent-first application platform. AWS is selling the ground they both run on.
That positioning is deliberate, and it carries a different set of risks than what either competitor faces. Amazon is not trying to own the agent. It is not building a CRM-native reasoning engine or a cross-platform agent registry. AWS is betting that the winning position in the agentic enterprise is the infrastructure layer: the compute, the model access, the managed runtime, and the tools ecosystem on which any agent framework, from any vendor, can run. The company that provides the foundation does not need to win the framework war. It needs to make the framework war irrelevant to its own revenue.
Bedrock AgentCore, which reached general availability in June 2026, is the architectural expression of this strategy. It is a managed runtime for AI agents that is framework-agnostic by design. Bring your Strands agent. Bring your LangGraph agent. Bring your CrewAI or LlamaIndex agent. AgentCore runs them all, in isolated microVM containers, with built-in session management, observability, and a growing set of managed tools. The pricing is per-vCPU-hour, not per-seat and not per-conversation. You pay for the compute your agents consume, and you pay separately for the model tokens they use.
The financial trajectory suggests the market is responding. AWS revenue reached $46 billion in Q3 2026, a 39 percent year-over-year increase, putting the business at a $184 billion annualized run rate. Operating income hit $17.8 billion in the quarter. The backlog stands at $578 billion. CEO Andy Jassy called Bedrock "the fastest-growing multi-billion-dollar service in AWS history." Fortune 500 Bedrock spending increased roughly sevenfold year over year, and token volume grew approximately seventeenfold. AI revenue is growing at triple-digit rates.
The question is whether infrastructure neutrality translates into strategic durability. AWS has volume. The question is whether it has defensibility.
What AgentCore Does
AgentCore is not an agent-building framework. It is the managed infrastructure layer that sits beneath agent frameworks, providing the operational capabilities that enterprises need to run agents in production at scale.
The architecture has five primary components.
The first is the managed runtime. AgentCore executes agents in isolated microVM environments using AWS Firecracker, the same technology that powers Lambda. Each agent instance gets its own isolated compute environment, which prevents one agent's behavior from affecting another. Sessions can persist for up to eight hours, long enough to handle complex multi-step workflows that exceed the typical request-response pattern. The runtime supports Strands (AWS's own open-source agent SDK), LangGraph, CrewAI, and LlamaIndex, with the framework-agnostic design allowing enterprises to bring whatever agent code they have written.
The second component is the built-in tool suite. AgentCore ships with a Code Interpreter for executing Python and other code within agent workflows, a Browser tool for web interaction, and a set of managed capabilities that agent frameworks can invoke without the developer building them from scratch. These tools run within the same security boundary as the agent, maintaining the isolation model.
The third is the AgentCore Gateway, which has become one of the most strategically significant components of the architecture. The Gateway provides MCP-compatible tool integration, allowing agents to discover and invoke external tools through a standardized protocol. As of late 2026, the Gateway supports MCP versions 2025-03-26, 2025-06-18, 2025-11-25, and the newest 2026-07-28 stateless revision. It includes enterprise governance features: centralized tool discovery through the Agent Registry, Cedar policy enforcement for MCP tools, and OAuth 2.0 On-Behalf-Of (OBO) token exchange for delegated identity. In February 2026, AWS integrated the Gateway with the Bedrock Responses API, enabling server-side tool execution where developers define MCP server connectors and Bedrock handles discovery and execution automatically.
The fourth component is observability. AgentCore provides OpenTelemetry-based tracing and monitoring, giving operations teams visibility into agent behavior, latency, error rates, and resource consumption. This is production infrastructure, not a demo feature. Organizations running agents at scale need the same observability they expect from any production workload, and OpenTelemetry is the standard the industry has converged on.
The fifth is the Agent Registry, which reached general availability in GovCloud in November 2026. The Registry provides centralized discovery and management of agents and MCP servers across an organization, addressing the inventory problem that every enterprise with more than a handful of agents encounters.
The Strands SDK and the Framework Question
AWS's relationship to agent frameworks illustrates the infrastructure-layer strategy in miniature.
Strands Agents is AWS's own open-source agent SDK, released under Apache 2.0 in May 2025. It has Python and TypeScript implementations and runs anywhere: Lambda, Fargate, EC2, EKS, or a developer's laptop. Strands is deployment-agnostic. It does not require AgentCore, and AgentCore does not require Strands.
This separation is the point. AWS built Strands as one option, not as the only option. The Strands Harness, a newer layer released in 2026, provides a preconfigured agent runtime that AWS claims matches the accuracy of competing harnesses while using 28 percent fewer tokens. But the open-source licensing and the deliberate decoupling from AgentCore signal that AWS does not intend to win the framework war through lock-in. It intends to win the infrastructure war by making the framework choice irrelevant to the infrastructure choice.
The contrast with the other vendors in this series is instructive. Salesforce built Atlas, a proprietary reasoning engine tightly integrated with its CRM data layer. Microsoft provides Copilot Studio and Foundry as the building surfaces, with Agent 365 as the governance layer above them. Both approaches tie the agent to the platform. AWS is taking the opposite approach: the agent framework is the customer's choice, and AWS provides the compute, the tools, and the operational infrastructure regardless of that choice.
The risk is symmetrical. Framework agnosticism means AWS has no proprietary reasoning layer to differentiate on. If the agent frameworks commoditize (and open-source dynamics suggest they will), the infrastructure layer commoditizes with them. AWS is betting that operational excellence, scale, and ecosystem breadth are more durable advantages than framework lock-in. That bet has worked in cloud infrastructure for 20 years. Whether it works in the agent era is an open question.
Payments: Agents That Can Spend Money
The most forward-looking capability in AgentCore is payments, and it signals where AWS thinks the agent economy is heading.
AgentCore Payments launched in preview on May 7, 2026, and reached general availability in August 2026. The implementation supports two wallet providers: Coinbase CDP (crypto-native) and Stripe Privy (traditional payments). The underlying protocol is x402, which enables machine-to-machine payments at the API level. An agent running on AgentCore can pay for an external API call, purchase data from an MCP server, or pay for web content access, all programmatically and within defined spending limits.
The governance controls are critical for enterprise adoption. Payments operate within session-level spending limits, so an organization can cap how much any individual agent session can spend. The spending parameters are set by the deploying organization, not by the agent, maintaining the human-in-the-lead principle from the Arion Research Operating Model Gap series.
Coinbase's Bazaar marketplace, launched alongside AgentCore Payments, lists over 10,000 x402-enabled endpoints, creating an initial ecosystem of paid services that agents can access. The combination of a managed runtime, payment infrastructure, and an endpoint marketplace creates the foundation for what the industry is calling the "agent economy": a market where AI agents are not just consumers of pre-provisioned APIs but active economic participants that discover, evaluate, and pay for services on behalf of their principals.
No other vendor in this series has shipped agent payment capabilities in production. Microsoft's Agent 365 governs agent behavior but does not enable agent commerce. Salesforce's Agentforce executes CRM workflows but does not include a payment layer. AWS is first to market with this capability, and the strategic implications extend beyond the technology. If agents become economic actors, the infrastructure layer that handles their financial transactions gains a new dimension of stickiness, one that infrastructure commoditization does not easily erode.
The caution is that "agent economy" remains more vision than reality. The x402 protocol is new. The endpoint ecosystem is nascent. Most enterprise agent deployments in 2026 operate within closed environments where agents access pre-authorized services, not open markets. Agent payments are a bet on a future that may take years to materialize, and AWS is building the infrastructure ahead of the demand. That is a strategy AWS has employed before (Lambda launched years before serverless became mainstream), and it has worked before. But early does not always mean right.
GovCloud: The Regulated Industry Card
AWS's GovCloud deployment of AgentCore is a competitive advantage that no other vendor in this series can match at the same level of maturity.
AgentCore reached general availability in GovCloud (US-West) in May 2026. The rollout has been methodical: memory, policy management, and the agent harness were added in August 2026. Web Search tools arrived in October 2026. The Agent Registry reached GovCloud GA in November 2026. Each addition extends the set of enterprise-grade agent capabilities available in a FedRAMP-authorized, ITAR-compliant environment.
The significance extends beyond the U.S. federal government. GovCloud availability signals readiness for any regulated workload where data residency, compliance certification, and sovereignty requirements are non-negotiable. Financial services, healthcare, defense contractors, and regulated utilities all face constraints that make running agent workloads on standard commercial cloud regions either impossible or prohibitively complex from a compliance perspective.
Microsoft serves the government market through Azure Government and has deep relationships with federal agencies. Salesforce has its Government Cloud. But neither has shipped a comparable framework-agnostic agent runtime in their government-certified environments. AWS's lead in GovCloud agent infrastructure is a structural advantage for a market segment where procurement decisions, once made, are extraordinarily sticky.
The Missionforce initiative (a Salesforce-NVIDIA collaboration for government-specific AI models) and Microsoft's Frontier Co. consulting play both address the government and regulated market, but they are targeting different layers: specialized models and implementation services, respectively. AWS is targeting the infrastructure layer, which is the foundation on which those specialized models and services run. The play is consistent with AWS's broader strategy: own the ground, not the building.
The Pricing Model
AgentCore's pricing reinforces the infrastructure positioning. While Microsoft charges per-user-per-month for governance and Salesforce charges per-conversation or per-action-credit, AWS charges per-vCPU-hour for compute.
The rates are approximately $0.0895 per vCPU-hour for v1 instances and $0.1276 for v2 instances. I/O wait time is not billed, so an agent that spends 40 percent of its session waiting for external API responses is charged only for the 60 percent of active compute. Model tokens are billed separately through standard Bedrock pricing.
This is utility pricing, the same model that AWS uses for EC2, Lambda, and every other compute service. It is transparent, granular, and directly tied to resource consumption. An organization can calculate its agent infrastructure costs the same way it calculates any other cloud workload: resource type multiplied by duration multiplied by rate.
The advantage is predictability and alignment with usage. Organizations that run a small number of agents lightly pay little. Organizations that run thousands of agents at scale pay proportionally. There is no per-seat commitment that creates shelfware if adoption is slower than expected, and no conversation-based meter that makes budgeting dependent on predicting customer interaction volumes.
The disadvantage is margin exposure. Utility pricing commoditizes over time. AWS has demonstrated for two decades that it will reduce prices as scale increases and competition intensifies. That pricing discipline has built the cloud business into a $184 billion run rate, but it has also trained the market to expect that infrastructure costs will decline. If agent compute follows the same trajectory as general compute, AWS's agent revenue will grow through volume, not through pricing power. Microsoft's governance premium and Salesforce's application-layer pricing both carry higher margins per unit of value delivered. AWS is playing the volume game, and the volume game requires that the total addressable market for agent compute continues to grow faster than prices decline.
The Coordination Gap
AWS's infrastructure-layer positioning creates a specific strategic gap that the Agent Coordination Gap series identified: being framework-agnostic at the infrastructure layer does not solve the coordination problem at the application layer.
AgentCore runs any framework, but it does not arbitrate between agents built on different frameworks. The Gateway provides tool connectivity through MCP, but MCP is a tool-use protocol, not an agent coordination protocol. An agent running on AgentCore can discover and invoke an MCP-compatible tool. It cannot discover, negotiate with, or resolve conflicts against another agent running on a different platform.
The Agent Coordination Gap Part 2 documented that MCP has reached 97 million monthly SDK downloads and over 10,000 active public servers, but 86 percent of implementations remain experimental. The protocol provides connectivity, which is necessary. It does not provide coordination, which is what enterprises need once they operate agents across multiple platforms.
Google's A2A protocol addresses agent-to-agent communication, and AWS has signaled interest in cross-platform interoperability. But as of November 2026, AgentCore's coordination capabilities are limited to what the individual agent frameworks provide internally. LangGraph prevents conflicts through graph topology. CrewAI's hierarchical mode assigns a manager agent. These work within a single framework on a single platform. They do not address the multi-vendor, multi-framework coordination problem that the Arbitration Gap article (Part 4 of the Agent Coordination Gap series) identified as the hardest unsolved problem in multi-agent architecture.
This is not a criticism unique to AWS. No vendor has solved cross-platform agent arbitration. But the gap is particularly relevant for AWS because the infrastructure-layer positioning attracts customers running heterogeneous agent estates, precisely the customers who need cross-platform coordination the most. AWS provides the compute. The customer still has to build the coordination layer.
The Commoditization Question
The central strategic risk for AWS in the agent era is the same risk it has navigated in cloud infrastructure for 20 years: the infrastructure layer commoditizes faster than the application and platform layers.
Microsoft's control plane strategy creates governance lock-in that is harder to replicate and harder to exit. Salesforce's customer data gravity and domain-specific reasoning create application-layer stickiness. AWS's infrastructure neutrality is a strength for customer acquisition (no framework lock-in, no model lock-in, run anything) and a weakness for customer retention (if the infrastructure is truly neutral, the customer can take their agents to Azure or GCP without changing a line of agent code).
The counterargument is that AWS has won this game before. EC2, S3, Lambda, and the rest of the AWS infrastructure stack are technically commodities: any cloud provider can offer virtual machines, object storage, and serverless functions. AWS built a $184 billion business on those commodities through operational excellence, ecosystem breadth, first-mover advantage, and relentless cost reduction. The company has demonstrated that infrastructure can be a high-volume, high-margin business if you execute well enough for long enough.
The agent era introduces a new variable: the value is migrating up the stack. In the first wave of cloud computing, the infrastructure layer captured a disproportionate share of value because applications depended on infrastructure capabilities (networking, storage, compute) that were hard to abstract away. In the agent era, the differentiation layers are governance (Microsoft's bet), customer data and domain reasoning (Salesforce's bet), and cross-platform orchestration (nobody's bet yet, as the Agent Coordination Gap series documents). If the value concentrates at those layers, the infrastructure layer may end up with volume but not margin.
AWS's Q3 2026 financials suggest this has not happened yet. Operating income of $17.8 billion on $46 billion in revenue is a 38.7 percent operating margin, a margin that most application companies would envy. But the agent-specific infrastructure is new, and the competitive dynamics of the agent infrastructure market are still forming. The question is whether AgentCore's framework-agnostic positioning creates enough ecosystem gravity to maintain margins as Azure and GCP build comparable agent infrastructure capabilities.
The payments capability is AWS's most interesting hedge against commoditization. If agent commerce becomes a significant transaction layer, the infrastructure provider that handles agent payments captures value that is not easily replicated by running the same agent on a different cloud. Payments create stickiness that pure compute does not. Whether that stickiness materializes depends on how quickly the agent economy develops, which is a question that no vendor can answer with certainty in 2026.
What re:Invent 2026 Should Clarify
AWS re:Invent 2026 runs November 30 through December 4, roughly three weeks from this writing. Based on the cadence of AgentCore releases throughout 2026 (GA in June, Payments GA in August, GovCloud expansions through November), the event should clarify several open questions.
First, multi-agent coordination. AWS has shipped the infrastructure to run individual agents. The gap is coordination across agents, frameworks, and platforms. Whether AWS announces native support for A2A or a proprietary coordination layer will signal how the company plans to address the highest-value, least-solved problem in multi-agent architecture.
Second, enterprise governance. Microsoft has defined the governance category with Agent 365. AWS has the Agent Registry and Gateway policy enforcement, but it has not shipped a unified governance product comparable to what Microsoft offers. Whether AWS positions governance as a managed service or continues to provide governance building blocks for customers to assemble themselves will indicate whether AWS sees governance as an infrastructure capability or a platform capability.
Third, pricing evolution. The per-vCPU-hour model is transparent but does not capture the value of higher-order capabilities like payments, governance, and coordination. Whether AWS introduces tiered pricing that reflects these capabilities, or maintains pure utility pricing, will signal how the company thinks about margin in the agent era.
Enterprise leaders attending re:Invent should evaluate announcements against these three questions. The infrastructure is solid. The strategic questions are about what gets built on top of it.
The Three-Layer Map
Across the first four articles in this series, a competitive map has emerged. The enterprise agentic AI market is sorting into three strategic layers, and each vendor's bet determines which layer it owns.
Microsoft owns the governance and control plane layer. Agent 365 provides identity, security, lifecycle management, and policy enforcement for agents regardless of where they were built. The value proposition is management. The lock-in mechanism is governance dependency.
Salesforce owns the application and domain layer. Agentforce 360, the Atlas Reasoning Engine, and the Koa model provide customer-facing agent capabilities anchored in the richest source of CRM data in the enterprise. The value proposition is customer intelligence. The lock-in mechanism is data gravity.
AWS owns the infrastructure layer. AgentCore provides the compute, runtime, tools, and (uniquely) the payments infrastructure on which agents from any framework run. The value proposition is neutrality and scale. The lock-in mechanism is operational gravity and, potentially, payment transaction dependency.
The question for enterprise leaders is not which layer is most important. All three are necessary. The question is which layer your organization should own versus rent, and which vendor's positioning best aligns with your architectural philosophy. An organization that wants to centralize governance under one umbrella will gravitate toward Microsoft. An organization that builds its agent strategy around customer data will gravitate toward Salesforce. An organization that prioritizes framework flexibility, multi-cloud optionality, and infrastructure-level control will gravitate toward AWS.
The Agent Coordination Gap series makes clear that no vendor has solved the coordination problem between these layers. The organization that treats vendor selection as a coordination architecture decision, not just a product evaluation, will be best positioned as the market matures.
Strategy Playbook
1. Test Framework Portability Before You Commit. AgentCore's framework-agnostic promise is its core value proposition. Validate it with your actual agent code. Deploy the same agent using Strands, LangGraph, and at least one other framework on AgentCore. Measure the operational differences: deployment complexity, session management behavior, observability quality, and Gateway tool integration. If framework portability is real in your environment, AgentCore reduces switching costs and preserves architectural flexibility. If portability is theoretical but friction-laden in practice, the value proposition weakens.
2. Model Your Infrastructure Economics Across Vendors. AgentCore's per-vCPU-hour pricing is transparent, but transparent pricing is not the same as lowest total cost. Model the same agent workload across AgentCore, Azure's agent infrastructure, and GCP's Vertex AI agent capabilities. Include model token costs (which vary by provider), I/O wait patterns (which AgentCore does not bill but others may), and the operational overhead of managing agents on each platform. The vendor with the lowest per-unit cost may not be the vendor with the lowest total cost once operational complexity is factored in.
3. Evaluate GovCloud Readiness If You Have Regulated Workloads. If your organization operates in government, financial services, healthcare, or any sector with data residency and compliance requirements, AgentCore's GovCloud availability is a differentiator. Map the GovCloud feature set (runtime, memory, policy, Web Search, Agent Registry) against your requirements. Identify any capability gaps between the commercial and GovCloud offerings. The GovCloud roadmap has been methodical, with new capabilities arriving quarterly, so gaps may close on a predictable timeline.
4. Watch Payments, But Build Governance First. AgentCore Payments is the most forward-looking agent infrastructure capability in the market. It is also the least mature in terms of enterprise adoption patterns. Before investing in agent payment capabilities, ensure your governance infrastructure is solid: decision authority tiers are defined (using the Operating Model Gap framework), spending limits are enforceable, and audit trails capture every agent financial transaction. Agent payments without agent governance is a risk that no enterprise should take. Build the governance floor first, then experiment with payments on top of it.
Arion Research advises enterprise leaders on AI strategy and the shift to a digital workforce.
