Skip to content
Go back

AgentCore and Foundry Wall Off the Session. Google Walls Off the Code.

An analyst uploads a spreadsheet to a shared analysis agent, the agent writes a script nobody reviewed, and whether that script can reach another analyst’s session, or the agent’s own credentials, depends on which cloud runs the agent. A platform engineer who runs that agent for a few hundred analysts has to pick a cloud before Monday’s architecture review, and the three clouds give different answers.

Amazon Bedrock AgentCore and Microsoft Foundry Agent Service wall off the whole session by default: the agent loop and any code it runs share one VM that serves one user. Google’s Gemini Enterprise Agent Platform walls off only the code: the agent loop shares a container with other concurrent requests, and generated code goes to a sandbox that does not inherit the agent’s credentials. The first default keeps users apart, and the second keeps the agent’s credentials away from its own code. AgentCore and Foundry sell a separate code sandbox as an option, while Google documents no per-session wall around the agent loop, so the trade-off is which protection you get by default and which one you have to build.

The platform layer sits inside a larger map of AI and data services across the three clouds, and companion posts cover agent identity, models, and cloud marketplaces.

Three platforms, side by side

Status as of November 18, 2026.

Amazon Bedrock AgentCoreMicrosoft Foundry Agent ServiceGoogle Agent Platform
Default boundaryOne Firecracker microVM per session; one EC2 instance per session on InstancesOne VM-isolated sandbox per session (hosted agents)Container instance serving concurrent requests (9 by default)
Separate code sandboxCode Interpreter, 2 vCPU and 8 GB per sessionCode Interpreter tool, $0.033 per sessionCode Execution, Shell, and Computer Use sandboxes in gVisor containers, without the agent’s credentials
Largest session2 vCPU and 8 GB by default; 8 vCPU and 32 GB with a resource configuration2 vCPU, 4 GiB8 vCPU, 32 GiB per container instance
Longest run8 hours (microVM); 14 days (Instances)Sessions persist until 30 days of inactivity; compute released after a 2-to-240-minute idle timeoutAgents running continuously for up to 7 days
FrameworksAny frameworkMicrosoft Agent Framework; LangChain, LangGraph, Deep AgentsADK first-class; LangChain, LangGraph, AG2, LlamaIndex templates
Policy enforcement pointAgentCore Gateway, Cedar rulesEntra Agent ID, guardrails, egress rulesAgent Gateway, IAM deny-by-default
Compute list priceNew runtime: $0.1276/vCPU-hr, $0.0169/GB-hr. Original runtime: $0.0895/vCPU-hr, $0.00945/GB-hr$0.0994/vCPU-hr, $0.0118/GiB-hr$0.085/vCPU-hr, $0.009/GiB-hr
Default capacity quota2,500 to 5,000 active sessions per account per region1,000 to 2,000 concurrent hosted sessions per subscription per region90 queries per minute per project per region (a rate, not a session count)

Quota sources: AgentCore, Foundry, Agent Platform.

What the default boundary wraps

AgentCore’s new runtime became the default for new runtimes on November 12; existing runtimes stay on the previous version until they are moved. “Every session still runs in its own hardware-isolated Firecracker microVM,” per AWS’s announcement. A session ends after 15 idle minutes by default and lives at most 8 hours, per the quotas page. Runtime Instances run on EC2 in your account for up to 14 days. There, a session “maps to one EC2 instance (1:1),” and agents that share a session share its credentials, per the Instances security model.

Foundry’s hosted agents “run in per-session VM-isolated sandboxes,” and they scale per session, with no replica count to tune. The largest sandbox is 2 vCPU and 4 GiB. When the idle timeout elapses, the platform releases the compute and saves the session’s home directory, and it deletes the session after 30 days of inactivity.

Google’s Agent Runtime packs requests into containers. “The value 9 represents the number of agent processes running in parallel within each container,” per the scaling guide, and container_concurrency, the number of concurrent requests per container, also defaults to 9 in the deployment guide. Generated code runs elsewhere: the sandbox page says sandbox code runs “inside a gVisor-isolated container and doesn’t inherit the identity or credentials of your parent agent,” and that actions in one sandbox don’t affect “other agents or users sharing the same runtime resources.” A new sandbox can take up to 2 minutes from a cold start, but “after they are provisioned, sandboxes usually spin up in seconds.”

Think of Google’s runtime as a restaurant table. The container is the table, concurrent requests are the diners, and anything risky gets cooked in a separate kitchen that never holds the diners’ wallets. The analogy breaks at the table. Diners can see each other’s plates, but Google does not document whether concurrent requests in one container can see each other’s memory or files.

On AgentCore or Foundry, if the agent runs the script inside its own session, the script stays in that analyst’s VM, away from every other analyst. My reading of both platforms’ docs is that the script also runs next to whatever credentials the session holds, unless the agent sends it to a separate sandbox: AgentCore Code Interpreter or Foundry’s Code Interpreter tool. On Google, the script goes to a Code Execution sandbox, which runs “without outbound internet or Virtual Private Cloud (VPC) network access” and without the agent’s credentials. The agent loop that wrote it still shares a container with other analysts’ requests.

Hourly rates don’t compare cleanly: Google bills a container serving several requests, AWS and Microsoft bill per session, and each has a rule that changes the math. AgentCore bills no CPU during I/O wait, and its new runtime reclaims idle memory after 120 seconds, per AgentCore pricing. Google says that “for Runtime, idle time spent waiting for the next prompt between turns is not billed,” per Agent Platform pricing. Foundry bills the container compute consumed, per Foundry pricing, and releases a session’s compute at its idle timeout.

Who runs the agent loop

All three clouds now offer a managed agent loop that a team configures instead of coding, at different release stages.

PlatformManaged loopStatusWhat you configure
AgentCoreHarnessGA since June 17; no additional charge for the harness itselfModel, tools, skills, memory, instructions
FoundryPrompt agents; Copilot harnessPrompt agents GA; Copilot harness in public previewInstructions, model, tools; Microsoft runs the loop and sandbox for harness agents
GoogleManaged Agents APIPreview since May 19Configuration, on Google’s Antigravity harness

The AgentCore harness accepts Bedrock, OpenAI, Gemini, or LiteLLM-compatible models and can switch mid-session, per the harness model docs. Foundry charges nothing extra “for creating or running Foundry-native agents using prompts and workflows”; you pay for model tokens and tools, per Foundry pricing. Google’s Managed Agents docs tell users not to put confidential data in it or use it for production yet.

Each cloud also has a business-user builder: AWS Quick agents and Flows, Copilot Studio, “a graphical, low-code studio,” on Microsoft, and Google’s Agent Studio, whose visual designer is in preview. Foundry’s own workflow designer, a preview feature, retires on December 1. After that date Foundry “continues to run YAML-based workflow definitions when you deploy them as a hosted agent,” and Microsoft points teams that want a visual designer to Azure Logic Apps. The AgentCore harness has no visual designer of its own.

Where policy gets enforced

Each platform enforces policy outside the agent’s own code, and AgentCore does it at the tool gateway. A policy engine attached to AgentCore Gateway evaluates tool calls in Cedar, and “Policy operates outside your agent code,” per the Policy GA announcement. Since August 6, temporal policies can enforce workflow sequencing and “require human approval before taking privileged actions.” Bedrock Guardrails in policy, GA since June 17, check the inputs of every call to a gateway target. A tool the agent calls directly, outside Gateway, is not covered.

Google’s choke point is the network layer. Agent Gateway went GA on June 18 for Google-managed runtimes and sits on agent traffic in both directions. “By default, all connections are blocked unless an explicit IAM policy grants access.” Model Armor on the gateway screens prompts and tool responses, GA since June 24, and plain-language semantic governance policies on tool use are in preview, per the release notes. Gateway coverage for GKE has been in preview since November 12; Cloud Run and Kubernetes clusters outside Google Cloud are in limited preview.

On Microsoft, identity and egress carry the enforcement. Every Foundry agent gets an Entra agent identity that “starts without resource permissions,” and Entra Agent ID is generally available. Admins can block an agent from Entra or Agent 365, but “agents created before the enforcement cutoff bypass Entra-state enforcement through a legacy exception,” per the governance guide. Hosted agents get network egress controls, enforced outside the sandbox and GA as of November 18. “Agent guardrails for content safety in Foundry Agent Service are in preview,” per the guardrails overview.

Can the analyst’s agent send the spreadsheet to an unapproved web address? Each platform can block it once configured, and the defaults differ. AgentCore runtimes deploy in public network mode with internet access unless you choose VPC mode, per the AgentCore CDK docs. A VPC runtime has no internet access without a NAT gateway, per the VPC guide, and Gateway policy sees only calls routed through Gateway. On Google, deny-by-default holds for traffic through a configured Agent Gateway; a sandbox with internet_access set to true gets “unrestricted outbound access to public IP addresses.” On Foundry, the egress rules attached to the agent decide, and the content guardrail that might catch the spreadsheet is preview.

What’s GA

Release status across the same eight capabilities, as of November 18:

CapabilityAgentCoreFoundryGoogle
RuntimeGA; managed session storage previewHosted agents GA; customer-owned AKS “coming soon,” public preview targeted for early DecemberAgent Runtime GA; A2A agents and bidirectional streaming preview
Managed loopHarness GAPrompt agents GA; Copilot harness previewManaged Agents API preview
MemoryGAPreviewSessions and Memory Bank GA
Gateway and policyGateway and Policy GAEgress controls GA; Azure Policy egress governance previewAgent Gateway GA on Google runtimes; GKE preview; semantic governance preview
IdentityGAEntra Agent ID GAAgent Identity GA since April 22
GuardrailsGuardrails in policy GAAgent guardrails previewModel Armor on Agent Gateway GA
EvaluationEvaluations GA; Optimization previewEvaluations and Insights GA; several agent evaluators previewEvaluation with simulated users, no preview label
SandboxesCode Interpreter and Browser GAComputer use and browser automation GA; Code Interpreter tool at $0.033 per sessionCode Execution, no preview label; Computer Use and Shell sandboxes GA since September 9

AgentCore’s session storage and Optimization are still preview; its new runtime carries the highest list rate of the three, runtimes start on a public network, and the harness has no visual designer. Foundry’s memory and agent guardrails are preview, its largest sandbox is 2 vCPU and 4 GiB, and its workflow designer retires December 1. Google’s managed loop, A2A hosting, and gateway coverage beyond its own runtimes are preview, and isolation between concurrent requests in one container is undocumented.

Where this stops

So what

For the platform engineer, Monday’s choice starts with the default boundary. If the analysis agent holds one analyst’s data per session and the main risk is one analyst reaching another’s files, a per-session VM (AgentCore or Foundry) gives the simpler answer, and the follow-up work is routing generated code to Code Interpreter so it stays away from the agent’s credentials. If the main risk is generated code using the agent’s credentials, Google’s default already strips them, and the follow-up work is confirming what concurrent requests in one container can see.

The enforcement point comes second. Controls that already live in Entra and Agent 365 map most directly to Foundry, network egress rules to Google’s gateway, and per-tool rules to AgentCore’s Cedar policies. Identity is a weak tiebreaker on its own: AgentCore keeps agents in an agent identity directory, Google’s Agent Identity is GA too, and what happens when one agent spans clouds is the subject of the agent identity post.

What I can’t answer yet is which default holds up if the analysis agent ends up writing and running code on most requests. AWS and Microsoft wall off the session and leave code-to-credential separation as an opt-in sandbox. Google strips credentials from the code by default and leaves the agent loop in a shared container. I don’t know which one breaks first at a few hundred analysts, or which one costs less once most sessions execute code, and I would like to see a public test that measures both on the same workload.


Share this post on:


Previous Post
An Agent's Credentials Cross Clouds. Its Off Switch Doesn't.
Next Post
Every Cloud Sells the Same AI Stack. Each One Anchors It Somewhere Else.