Three deadlines are colliding at once in cloud AI right now. OpenAI retired its Assistants API on August 26, 2026, taking the Azure OpenAI Assistants API (Preview, classic) down with it on the same date. AWS pushed Amazon Bedrock AgentCore and the wider Bedrock 2 platform into general availability with a visual agent builder in July. And Google keeps expanding Vertex AI Agent Builder and Agent Engine into new regions almost monthly. If you’re choosing where to build production AI agents this quarter, the decision now has real dollar figures attached to it, not just marketing slides.
This comparison lines up AWS Bedrock AgentCore, Azure AI Foundry Agent Service, and Google Vertex AI Agent Builder (including Agent Engine) on pricing, model catalogs, region coverage, memory and orchestration features, and migration paths. Every number below comes from official pricing pages, vendor documentation, or named third-party analyses published in 2026 — nothing is estimated from an old blog post or padded with invented benchmarks.
Why This Comparison Matters Right Now
The trigger event is unglamorous but consequential: Microsoft’s own documentation states plainly that “the Assistants API is deprecated and will be retired on August 26, 2026,” and that applies to both OpenAI’s hosted Assistants API and the Azure OpenAI Assistants API (Preview) classic endpoint. Teams that built production chatbots, coding copilots, or internal tools on top of Assistants threads have had to migrate to Azure AI Foundry agents built on the newer Responses API, and there’s no automated thread migration tool — you rebuild the session logic by hand.
That deadline lands in the same month AWS pushed its own agent stack forward. Amazon Bedrock AgentCore reached general availability with published per-vCPU pricing, and AWS layered Bedrock Guardrails support directly into AgentCore across five regions on June 17, 2026. Meanwhile Google has been quietly widening Vertex AI Agent Engine’s regional footprint, adding northamerica-northeast2 (Toronto) in Q1 2026 and continuing to update the Agent Builder documentation through mid-August. None of the three vendors sat still this year, and the result is that “AI agent platform” now means three genuinely different architectures, not three brands selling the same thing.
Cloud AI spending overall backs up why this matters. AI-related workloads made up roughly 19% of total cloud spend in 2026, up from 8% in 2023, and the big three’s growth rates diverged sharply on the back of it: Google Cloud grew about 63% year-over-year in Q1 2026, Azure grew around 40%, and AWS grew in the 19-28% range depending on the quarter measured. Sundar Pichai told analysts on the Q1 earnings call that “AI is now the largest tailwind for cloud,” and agent-building services are where that tailwind shows up first in enterprise budgets.
What Each Platform Actually Is
Before the numbers, it helps to know that these three products don’t solve the same problem the same way.
AWS Bedrock AgentCore
AgentCore is a set of modular runtime services — Runtime, Memory, Gateway, Browser, Code Interpreter, Identity, Observability, and Evaluations — that you assemble around whichever foundation model you choose. AWS explicitly designed it to be model-agnostic: it works with models inside or outside Amazon Bedrock, including OpenAI, Google’s Gemini, Anthropic’s Claude, Amazon Nova, Meta Llama, and Mistral. That’s a deliberate contrast with Azure and Google, which lean toward their own first-party model families. AgentCore runs in 15 AWS regions, including Mumbai, Seoul, Singapore, Sydney, Tokyo, Canada Central, Frankfurt, Ireland, London, Paris, Stockholm, São Paulo, N. Virginia, Ohio, and Oregon.
Azure AI Foundry Agent Service
Foundry Agent Service is Microsoft’s successor to the OpenAI Assistants API pattern, rebuilt on top of the newer Responses API. It’s tightly coupled to Azure OpenAI models and a growing set of “Foundry models sold by Azure,” and its regional and quota documentation was last refreshed August 24, 2026 — just two days before the Assistants API cutoff, which tells you how tightly Microsoft is managing that transition. Model token usage is billed separately through the standard Foundry Models pricing page; the Agent Service page itself only covers the orchestration layer.
Google Vertex AI Agent Builder / Agent Engine
Google’s stack splits into Agent Builder (the design and grounding layer, including Vertex AI Search for retrieval-augmented generation) and Agent Engine (the managed runtime that actually executes and hosts agents). It’s the most Gemini-native of the three, and Google has also been rolling related capability into “Agentspace,” its enterprise agent hub branding. Agent Engine picked up new regional availability, including Toronto, in the most recent release cycle, and the documentation was last updated August 18, 2026.
Full Specs Comparison Table
| Attribute | AWS Bedrock AgentCore | Azure AI Foundry Agent Service | Google Vertex AI Agent Builder |
|---|---|---|---|
| Architecture model | Modular runtime services (Runtime, Memory, Gateway, Browser, Code Interpreter, Identity) | Unified agent layer on the Responses API, successor to Assistants API | Agent Builder (design/grounding) + Agent Engine (managed runtime) |
| Model support | Model-agnostic: OpenAI, Gemini, Claude, Amazon Nova, Llama, Mistral | Azure OpenAI models plus Foundry-sold models | Gemini family, Gemini-native orchestration |
| Regions (agent runtime) | 15 AWS regions | Regional support documented; expanding as of Aug 24, 2026 | Adding regions incl. Toronto (northamerica-northeast2) |
| Runtime compute pricing | $0.0895 per vCPU-hour + $0.00945 per GB-hour | Agent-layer priced separately; model tokens via Foundry Models pricing | $0.0864 per vCPU-hour + $0.0090 per GB-hour |
| Session / memory pricing | Short-term: $0.25/1,000 events; long-term storage $0.75/1,000 (built-in) or $0.25/1,000 (custom); retrieval $0.50/1,000 | Not published as a standalone per-session meter in current docs | Sessions and Memory Bank: $0.25 per 1,000 events |
| Tool/gateway routing pricing | $0.005 per 1,000 API invocations; $0.025 per 1,000 search invocations; $0.02 per 100 tools indexed/month | Bundled into Foundry orchestration, no separate published gateway meter | RAG/grounding via Vertex AI Search: $4.00/1,000 standard queries, $6.00/1,000 advanced queries |
| Guardrails / safety | Bedrock Guardrails integrated into AgentCore (GA June 17, 2026): content filters, denied topics, sensitive-info filters, contextual grounding checks | Content filtering via Azure AI Content Safety, integrated at the Foundry layer | Safety filters via Vertex AI model safety settings and Agent Builder policies |
| Free tier | Consumption-based, no upfront commitment or minimum fee | Standard Azure free-tier credits apply; no dedicated Agent Service free quota published | ~50 vCPU-hours + 100 GB-hours/month Agent Engine quota, plus $300 new-customer credit for 90 days |
| Underlying API | Bedrock Converse / native AgentCore APIs | Responses API (replaces Assistants API) | Vertex AI Agent Engine API / Agentspace |
| Primary SDK | Strands Agents SDK, Bedrock SDKs, boto3 | Azure AI Foundry SDK, Azure OpenAI SDK | Vertex AI SDK, ADK (Agent Development Kit) |
| Cloud market share (Q1 2026) | ~30% of global cloud infrastructure spend | ~25% | ~13% |
| Cloud revenue growth (YoY, early 2026) | ~19-28% | ~40% | ~63%, AI-driven per Google’s earnings call |
| Documentation last updated | Aug 26, 2026 (models page) | Aug 24, 2026 (limits/quotas/regions) | Aug 18, 2026 (Agent Builder docs) |
Note what’s missing from that table: neither Microsoft nor Google publishes a standalone per-session or per-invocation meter with the same granularity AWS does for AgentCore Gateway and Memory. That’s not a gap in our research — it reflects how differently the three vendors structure their pricing pages. Azure bundles agent orchestration costs into the broader Foundry Models pricing, and Google spreads costs across Agent Engine compute, Memory Bank events, and Vertex AI Search queries rather than a single “agent” line item.
Pricing Breakdown: What a Production Agent Actually Costs
Sticker prices for cloud AI agents are almost never the final bill — token costs, memory events, and tool calls all stack on top of the base runtime rate. Here’s the clearest published breakdown for each platform’s core compute meter.
| Cost component | AWS Bedrock AgentCore | Google Vertex AI Agent Engine | Azure AI Foundry Agent Service |
|---|---|---|---|
| Compute (CPU) | $0.0895 / vCPU-hour | $0.0864 / vCPU-hour | Not separately metered; billed via underlying Foundry compute/model consumption |
| Compute (memory) | $0.00945 / GB-hour (peak, active only) | $0.0090 / GB-hour | Not separately metered |
| Session/event storage | $0.25 / 1,000 short-term events | $0.25 / 1,000 session/memory events | No published standalone meter |
| Long-term memory storage | $0.75 / 1,000 memories per month (built-in strategy) or $0.25 / 1,000 (custom) | Included under Memory Bank event pricing | No published standalone meter |
| Memory retrieval | $0.50 / 1,000 retrievals | Included under Memory Bank event pricing | No published standalone meter |
| Tool/search routing | Gateway: $0.005/1,000 API calls, $0.025/1,000 search calls, $0.02/100 tools indexed monthly | Vertex AI Search grounding: $4.00/1,000 standard queries, $6.00/1,000 advanced queries | Bundled into Foundry orchestration |
| Guardrails/safety add-on | Content filters $0.15/1,000 text units; denied topics $0.15/1,000; sensitive-info filters $0.10/1,000; image filtering $0.00075/image | Included in model safety settings, no separate line item published | Azure AI Content Safety priced separately from Foundry Agent Service |
| Illustrative monthly example | ~$35.18/month for a moderate single-agent workload (runtime + memory combined, per independent cost breakdown) | ~$150-$500/month for one support agent handling a few hundred conversations/day with RAG | Not independently benchmarked at this granularity in current sources |
Two things jump out. First, AWS and Google’s raw compute meters sit close together — $0.0895 versus $0.0864 per vCPU-hour, a gap of roughly 3.6% — so compute alone won’t decide your bill. Second, AWS is the only one of the three that publishes a fully itemized cost breakdown across memory, gateway, and guardrails, which makes AgentCore easier to forecast precisely but also means the “true” all-in cost of an equivalent Azure or Google agent is harder to pin down without running your own workload and reading the consolidated bill.
Model token costs sit on top of every one of these numbers, on all three clouds. As a reference point, Azure’s Foundry-hosted GPT-5.4 pricing (published March 2026) runs $2.50 input / $0.25 cached / $15 output per million tokens at contexts up to 272K, rising to $5.00 input / $0.50 cached / $22.50 output beyond that, with GPT-5.4 Pro priced separately at $30 input / $180 output per million tokens. That’s a reminder that for any chat-heavy or document-heavy agent, the model bill will usually dwarf the orchestration-layer bill on all three clouds.
Model Catalog and Context Window Strategy
This is where the three platforms diverge most in philosophy. AWS treats the model as a swappable component: Bedrock’s catalog spans Anthropic Claude (including Claude Opus 5 and Claude Sonnet 5, both broadly available across Anthropic’s cloud partners in 2026), OpenAI’s GPT-5.6 family (Sol, Terra, and Luna tiers added to Bedrock in July 2026), Amazon’s own Nova line, Meta Llama, Mistral, and Google’s Gemma 4 open-weight models — the last of which landed in Amazon Bedrock’s AWS GovCloud (US-West) region on July 30, 2026, specifically for regulated and public-sector customers.
Azure goes the other direction: Foundry Agent Service is built around Azure OpenAI models first, plus a growing but smaller set of “Foundry-sold” third-party models. That’s a strength if your organization has already standardized on OpenAI’s models through a Microsoft enterprise agreement, and a limitation if you want first-class access to Claude or open-weight alternatives inside the same orchestration layer.
Google is the most vertically integrated: Vertex AI Agent Builder is built to run on Gemini models by default, with Gemini 3 Pro generally available across 12 Vertex AI regions as of May 2026. That tight coupling means less catalog choice than AWS, but tighter integration between the model, Vertex AI Search grounding, and the Agent Engine runtime — all three pieces are designed and versioned together rather than bolted on separately.
None of the three vendors published a single unified “max context window for agents” figure in current documentation — context limits are set at the model level, not the orchestration layer, and vary by which specific model you attach to the agent. If your workload depends on a specific context length, check the model card for whichever model you plan to route through AgentCore, Foundry, or Agent Builder rather than assuming a platform-wide ceiling.
Memory, Orchestration, and Multi-Agent Support
AgentCore Memory is the most explicitly productized of the three memory systems. It separates short-term, in-session memory (billed per 1,000 new events) from long-term, cross-session memory (billed per 1,000 stored memories per month, plus a separate retrieval fee). That event-based pricing model means a chatty agent with long back-and-forth conversations costs differently than an agent making occasional long-lived memory writes — worth modeling explicitly before committing to a workload size.
Google’s Memory Bank, part of Agent Engine, follows a similar event-based model at $0.25 per 1,000 session and memory events, but Google folds retrieval into the same meter rather than splitting it out. Combined with Vertex AI Search for retrieval-augmented generation, Google’s memory story leans harder on search-grounded context than persistent structured memory.
Azure’s Foundry Agent Service, being the newest of the three in its current form (the Responses API-based version only fully replaced Assistants API in the same month as this article), doesn’t yet publish a standalone memory pricing meter. Session and thread state exist, but the cost is folded into general Foundry compute and model consumption rather than itemized. For teams doing careful FinOps planning, that makes Azure’s agent memory costs the hardest of the three to forecast in advance.
On multi-agent orchestration: AWS’s Gateway service is explicitly built for tool discovery and routing across multiple agents and tools, with semantic search over available tools priced separately from direct API invocation. That’s a meaningfully different design from a single-agent-with-tools pattern, and it’s the piece most directly aimed at teams building agent swarms rather than one chatbot.
Guardrails, Safety, and Compliance
Bedrock Guardrails reaching general availability inside AgentCore on June 17, 2026 — across US East (N. Virginia), Europe (London), Europe (Stockholm), Asia Pacific (Sydney), and Asia Pacific (Tokyo) — is the clearest recent safety milestone among the three. Pricing is itemized per safeguard: content filters run $0.15 per 1,000 text units of text or $0.00075 per image, denied-topics filtering is $0.15 per 1,000 text units, sensitive-information filters run $0.10 per 1,000 text units, and contextual grounding checks (which catch hallucinated claims against a source document) are also $0.10 per 1,000 text units.
Azure routes safety through Azure AI Content Safety, a mature, separately billed service that predates the current Foundry Agent Service and integrates with it. Google applies model-level safety settings plus Agent Builder policy controls, without a distinct per-unit guardrails price list published alongside Agent Engine.
For regulated industries specifically, AWS’s GovCloud availability of Gemma 4 (as of July 30, 2026) and the region-restricted Guardrails rollout both signal that AWS is treating compliance-tier availability as a first-class rollout target, not an afterthought bolted on after commercial GA.
Real-World Use Cases and Examples
Five patterns show up repeatedly in how teams are actually deploying these platforms in mid-2026:
- Multi-model customer support routing on AWS. Teams that need to route different ticket types to different models — say, Claude Opus 5 for complex escalations and a cheaper Amazon Nova model for routine FAQs — use AgentCore’s model-agnostic Gateway to avoid rewriting orchestration logic every time they swap a model. Because Gateway indexes tools separately from the model call itself, a support desk can add a new “check refund status” tool without touching the underlying model routing at all.
- Azure OpenAI shops migrating off Assistants. Any team that built a production assistant on the classic Assistants API before August 26, 2026 has had to move it to Foundry Agent Service on the Responses API. This is less a choice than a forced migration, and it’s currently the single largest driver of Azure agent adoption in the wild. Teams with heavy file-search usage in particular report the migration takes longer than a simple SDK swap, since chunking and retrieval defaults changed between the two APIs.
- RAG-heavy internal knowledge agents on Google. Vertex AI Search’s per-query grounding pricing ($4.00-$6.00 per 1,000 queries) makes Google’s stack a natural fit for internal document Q&A agents where retrieval quality matters more than raw model choice. Legal, HR, and internal engineering-wiki bots are the most common deployment pattern, since those workloads are read-heavy and benefit from Vertex AI Search’s grounding rather than raw model creativity.
- Regulated-industry deployments on AWS GovCloud. Healthcare and public-sector teams needing FedRAMP-aligned infrastructure gravitate toward AgentCore specifically because Bedrock’s GovCloud model catalog (including Gemma 4 as of July 2026) and regional Guardrails rollout track compliance requirements closely. The combination of itemized guardrails pricing and GovCloud availability lets compliance teams cost out a deployment before it ever touches a security review.
- Microsoft 365-integrated copilots on Azure. Enterprises already paying for Microsoft 365 Copilot licenses extend the same agents into Foundry Agent Service to keep identity, compliance, and billing inside one Microsoft enterprise agreement rather than adding a second cloud vendor relationship. This is especially common in industries with existing heavy Microsoft procurement contracts, where adding a second cloud vendor for agents is a harder internal sell than extending an existing one.
Migration Guide: Moving Off the Assistants API
If you’re one of the teams forced to move by the August 26, 2026 retirement, here’s the practical path, based on Microsoft’s own migration documentation and independent migration writeups published in August 2026.
- Inventory every Assistants API call site. Search your codebase for `assistants.create`, `threads.create`, and `runs.create` calls — these are the three primary Assistants API primitives that don’t map one-to-one onto the Responses API.
- Map threads to Foundry sessions. There is no automated thread migration tool from Microsoft, so existing conversation history in Assistants threads needs to be manually exported and re-imported as Foundry Agent Service session state if you need to preserve it.
- Re-implement tool/function definitions. The Responses API structures function calling differently than Assistants did; test each tool definition individually rather than bulk-porting the JSON schema.
- Swap file-search and code-interpreter references. Both built-in tools exist under new names/configurations in Foundry Agent Service — confirm behavior parity in a staging environment before cutover, since retrieval chunking defaults can differ.
- Update SDK versions. Move to the current Azure AI Foundry SDK; the older Assistants-specific SDK helper methods are being deprecated alongside the API itself.
- Run parallel traffic before cutover. Mirror a percentage of production traffic to the new Foundry agent for at least a week to catch behavioral drift in responses before fully decommissioning the Assistants-based path.
- Decommission Assistants resources after the deadline. Once verified, delete lingering Assistants threads and assistants to avoid confusion — they stop functioning after August 26, 2026 regardless.
Teams migrating from a different starting point — say, a homegrown LangChain deployment on plain EC2, or an existing Google Dialogflow CX bot — face a similar sequence: inventory the tool/function definitions first, since those almost never port cleanly between platforms, then migrate model calls, then rebuild memory/session handling last, since that’s the piece each platform implements most differently.
Pros and Cons
AWS Bedrock AgentCore
Pros: Model-agnostic across six-plus model families; the most granular, itemized pricing of the three; region coverage extends to GovCloud for regulated workloads; Gateway is purpose-built for multi-agent tool routing.
Cons: The itemized pricing model means more line items to track and forecast; modular architecture (Runtime, Memory, Gateway as separate services) has a steeper learning curve than a single unified agent object; slightly higher raw compute rate than Google’s Agent Engine.
Azure AI Foundry Agent Service
Pros: Cleanest migration path for existing Azure OpenAI/Assistants API customers; deep integration with Microsoft 365 and enterprise identity (Entra ID); consolidates billing inside an existing Microsoft enterprise agreement.
Cons: Least itemized public pricing of the three, making cost forecasting harder; model catalog is the narrowest, leaning heavily on Azure OpenAI; the forced Assistants API migration deadline has left some teams migrating reactively rather than by choice.
Google Vertex AI Agent Builder
Pros: Lowest published raw compute rate ($0.0864/vCPU-hour); tightest integration between grounding (Vertex AI Search), memory, and the Gemini model family; generous free-tier quota (~50 vCPU-hours + 100 GB-hours monthly) plus a $300/90-day new-customer credit.
Cons: Most Gemini-centric of the three, limiting model choice compared to AWS; RAG/grounding query costs ($4-$6 per 1,000 queries) can add up quickly for high-volume search-heavy agents; smallest of the big three by cloud market share (~13% versus AWS’s ~30% and Azure’s ~25%), which can matter for enterprise procurement and support SLAs.
Use-Case Recommendations
| If your priority is… | Choose | Why |
|---|---|---|
| Model flexibility across vendors (Claude, GPT, Llama, Nova) | AWS Bedrock AgentCore | Only platform explicitly designed to be model-agnostic across six-plus families |
| You’re already locked into Azure OpenAI / Microsoft 365 | Azure AI Foundry Agent Service | Consolidated billing, identity, and Copilot integration inside one Microsoft agreement |
| Heavy retrieval-augmented generation over internal documents | Google Vertex AI Agent Builder | Vertex AI Search grounding is purpose-built and tightly coupled to Agent Engine |
| Regulated/public-sector workloads needing GovCloud | AWS Bedrock AgentCore | Gemma 4 and Guardrails rollouts both prioritized GovCloud/compliance regions in 2026 |
| Multi-agent swarms with dynamic tool discovery | AWS Bedrock AgentCore | Gateway service is purpose-built for semantic tool search and routing across agents |
| Lowest raw compute cost at small scale | Google Vertex AI Agent Builder | $0.0864/vCPU-hour plus a meaningful free-tier quota for prototyping |
| Forced migration off a retiring Assistants API deployment | Azure AI Foundry Agent Service | It’s the direct, vendor-recommended successor product for that exact workload |
Sample Setup: Calling Each Platform’s Agent Runtime
To illustrate how differently these three platforms structure a basic agent invocation, here’s a minimal, representative call pattern for each — not a full working app, just enough to show the shape of the API.
# AWS Bedrock AgentCore Runtime invocation (boto3)
import boto3
client = boto3.client("bedrock-agentcore", region_name="us-east-1")
response = client.invoke_agent_runtime(
agentRuntimeArn="arn:aws:bedrock-agentcore:us-east-1:123456789012:runtime/my-agent",
payload={"input": "Summarize this quarter's support tickets"},
sessionId="session-001"
)
print(response["output"])# Azure AI Foundry Agent Service (Responses API)
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
client = AIProjectClient(
endpoint="https://my-foundry-project.services.ai.azure.com",
credential=DefaultAzureCredential()
)
response = client.agents.create_response(
agent_id="asst_support_agent",
input="Summarize this quarter's support tickets"
)
print(response.output_text)# Google Vertex AI Agent Engine invocation
from vertexai import agent_engines
remote_agent = agent_engines.get("projects/my-project/locations/us-central1/reasoningEngines/123")
response = remote_agent.query(
input="Summarize this quarter's support tickets",
session_id="session-001"
)
print(response["output"])The pattern differences matter operationally: AWS and Google both use an explicit session ID you manage yourself, while Azure’s agent ID references a pre-configured agent resource with session state handled by the Foundry project. If your team is used to one pattern, budget real ramp-up time for the other two — this isn’t a drop-in SDK swap.
Independent Cost Benchmarks From Third-Party Analysts
Vendor pricing pages tell you the per-unit rate; they rarely tell you what a real workload actually costs at the end of the month. Three independent breakdowns published in 2026 fill that gap and are worth reading directly if you’re modeling a specific deployment.
CloudZero’s Amazon Bedrock pricing breakdown lays out the full per-model token matrix across the Bedrock catalog, including Amazon Nova Micro at $0.035 input / $0.14 output per million tokens with a 128K context window — the cheapest model on Bedrock by a wide margin — up through Amazon Nova Pro at $0.80 / $3.20 per million tokens with a 300K context window. That analysis is useful specifically because it shows how much the model choice inside AgentCore, not just the AgentCore runtime fee itself, drives total spend.
Cipher Projects’ AgentCore pricing analysis breaks the twelve separate AgentCore pricing components down into two practical cost drivers: how many active compute-hours your agent actually consumes versus how many discrete memory and gateway events it generates. Their conclusion, echoed by a separate breakdown from Nerova that arrives at an illustrative $35.18/month total for a moderate single-agent workload combining runtime and memory costs, is that memory event volume — not raw compute time — is usually the line item teams underestimate when they first budget an AgentCore deployment.
On the Google side, BetterClaw’s Vertex AI Agent Builder pricing review models three usage tiers directly from Google’s published per-vCPU and per-GB rates: prototype-stage agents running inside free-tier quotas for a few cents to a few dollars a month, small production deployments (one support agent, a few hundred conversations daily, RAG retrieval enabled) landing around $150-$500 a month, and heavy production usage — thousands of daily conversations, Memory Bank enabled, Gemini Pro-class models, heavy search volume — running $500 to $2,000-plus monthly. That tiered breakdown is the clearest publicly available cost ladder for any of the three platforms.
For the Azure migration deadline specifically, endoflife.ai’s coverage of the Assistants API retirement is worth reading in full — it flags that the deadline lands in the last week of August, “when half the teams who need to act are on vacation,” a scheduling detail that has driven a wave of last-minute migration activity documented across multiple independent Azure migration guides published in August 2026.
Developer Experience: SDKs, CLIs, and Framework Support
Day-to-day build experience differs almost as much as pricing does. AWS ships the Strands Agents SDK alongside standard boto3 bindings, and AgentCore’s modular design means a developer typically wires up Runtime, Memory, and Gateway as separate resources with separate ARNs — more upfront configuration, but each piece can be swapped, versioned, or scaled independently. That modularity is a natural fit for teams already comfortable with composing individual AWS services rather than consuming one packaged product.
Azure’s developer path runs through the Azure AI Foundry SDK and the Azure AI Foundry portal, which bundles agent creation, thread/session management, and model deployment into a single project-scoped resource. That’s a smaller number of moving parts to learn than AgentCore, at the cost of less granular control over each layer — you generally can’t swap out just the memory component without touching the rest of the agent configuration.
Google’s path runs through the Vertex AI SDK and the Agent Development Kit (ADK), Google’s open framework for defining agent logic that can then be deployed to Agent Engine as a managed runtime. The ADK’s appeal is that agent logic can be developed and tested locally before being pushed to Agent Engine, which shortens the local-to-cloud iteration loop compared to platforms where agent definitions live natively inside a cloud console from the start.
None of the three platforms locks you out of popular open-source agent frameworks entirely — LangChain- and LlamaIndex-based agents can be deployed as the underlying logic inside AgentCore Runtime, wrapped inside a Foundry Agent Service session, or packaged for Agent Engine via the ADK. But official, first-party framework support and tooling maturity currently favor AWS and Google slightly more than Azure, largely because Foundry Agent Service is the newest of the three products in its current Responses API-based form.
Verdict: Which Platform Wins
There’s no single winner here, and the data backs that up rather than forcing it. If model flexibility and itemized cost control matter most, AWS Bedrock AgentCore is the strongest technical choice — it’s the only platform of the three that treats the model as fully swappable and publishes a granular price for every meter, from Gateway search calls down to guardrail text units. If your organization is already an Azure OpenAI customer and got caught by the Assistants API retirement, Foundry Agent Service isn’t really an optional comparison — it’s the assigned migration path, and the deeper Microsoft 365 integration is a genuine advantage if you’re staying inside that ecosystem anyway.
Google Vertex AI Agent Builder earns its place for a narrower but real use case: RAG-heavy internal agents where retrieval quality and tight Gemini integration matter more than model choice, especially at smaller scale where the free-tier quota and lower per-vCPU-hour rate meaningfully reduce prototyping costs. Its 13% share of global cloud infrastructure spend versus AWS’s 30% and Azure’s 25% (as of Q1 2026) also means smaller partner and support ecosystems in some regions, worth factoring into enterprise procurement decisions.
The practical takeaway for August 2026: pick based on where your models and existing cloud spend already live, not on which platform has the flashiest agent-builder UI. All three are consumption-priced with no major lock-in penalty for a small pilot, so the lowest-risk move for most teams is to run a two-week proof of concept on the platform tied to your dominant model vendor, then compare the actual itemized bill against these published rates before committing a production workload.
Frequently Asked Questions
What happened to the OpenAI Assistants API?
Both OpenAI’s hosted Assistants API and the Azure OpenAI Assistants API (Preview, classic) were retired on August 26, 2026, according to Microsoft’s own documentation. There’s no automated migration tool for existing threads; teams need to manually rebuild session and conversation state on the newer Responses API, which powers Azure AI Foundry Agent Service.
Is AWS Bedrock AgentCore more expensive than Vertex AI Agent Engine?
On raw compute, AgentCore’s published rate is $0.0895 per vCPU-hour versus Agent Engine’s $0.0864 per vCPU-hour — a roughly 3.6% gap in Google’s favor on compute alone. But AgentCore adds itemized memory, gateway, and guardrails fees that Google folds into broader meters, so total cost depends heavily on your specific workload shape, particularly how many memory events and tool calls your agent generates.
Which platform supports the most foundation models?
AWS Bedrock AgentCore, by a clear margin. It’s explicitly model-agnostic and supports OpenAI, Google Gemini, Anthropic Claude, Amazon Nova, Meta Llama, and Mistral models, including newly added GPT-5.6 tiers (Sol, Terra, Luna) as of July 2026 and Google’s Gemma 4 open-weight models in AWS GovCloud as of July 30, 2026. Azure leans on Azure OpenAI models primarily, and Google leans on its own Gemini family.
Can I use Claude models on Azure or Google Cloud agent platforms?
Claude Opus 5 is available through Anthropic’s direct cloud integrations on AWS Bedrock, Google Vertex AI, and Microsoft Azure as of mid-2026, so yes, in principle you can reach Claude models from any of the three. But how well that model plugs into each platform’s native agent orchestration layer (memory, tool calling, guardrails) varies — AWS’s AgentCore is the platform built specifically to treat third-party models as first-class citizens in its agent runtime.
What replaces the Assistants API pattern on AWS and Google?
Neither AWS nor Google ever offered a direct equivalent to OpenAI’s Assistants API, so there’s no forced migration deadline on those platforms tied to this specific retirement. AWS’s closest analog has always been Bedrock Agents, now consolidated under AgentCore; Google’s closest analog is Vertex AI Agent Builder combined with Agent Engine.
Does AgentCore, Foundry Agent Service, or Agent Builder have a free tier?
Google Vertex AI Agent Engine has the clearest published free quota: roughly 50 vCPU-hours plus 100 GB-hours of Agent Engine usage per month, on top of the general $300 Google Cloud credit for new customers over their first 90 days. AWS AgentCore is consumption-based with no upfront commitment or minimum fee, which functionally makes very small test workloads inexpensive, though it isn’t a dedicated “free tier” in the same sense. Azure doesn’t publish a dedicated Agent Service free quota beyond standard Azure trial credits.
Which cloud is growing fastest in AI right now?
Google Cloud posted the fastest year-over-year growth among the three in early 2026, at roughly 63%, driven heavily by AI workloads according to comments on Google’s Q1 earnings call. Azure grew around 40% YoY over the same period, and AWS grew in the 19-28% range. AWS still holds the largest overall share of cloud infrastructure spend at roughly 30% as of Q1 2026, versus Azure’s ~25% and Google’s ~13%.
Related Coverage
- How to Build Amazon Bedrock AI Agents: 12 Steps [2026]
- Azure AI Foundry Agents: 12 Steps, 100 Min [2026]
- AWS Lambda vs Azure Functions vs GCP: 4x Timeout Gap [2026]
- HashiCorp Vault vs AWS vs Azure Key Vault: 15x Gap [2026]
- AWS Control Tower vs Azure Landing Zone: $913 Gap [2026]
- DynamoDB Vector Search Setup: 13 Steps, 100 Min [2026]