AWS spent the week of September 14-21, 2026 rewriting the rules for how cloud agents run in production. It shipped a rebuilt runtime that starts containers in about two seconds instead of thirty, gave OpenAI’s newest model a home on Bedrock, and open-sourced an agent framework that runs on rival clouds. Taken together, the three moves mark the point where “AI agent infrastructure” stopped being a marketing phrase and became a real line item on a cloud bill.
The centerpiece is AWS AgentCore Runtime v2, which AWS shipped on September 18, 2026. It is the clearest signal yet that the three major clouds now treat long-running, stateful AI agents as a distinct workload class, not a variant of a web request. Google and Microsoft made similar bets earlier in the year. What changed this month is that AWS closed the performance gap that made its original AgentCore release feel unfinished, and it did so while also releasing a cross-cloud agent framework that, on paper, undercuts its own platform lock-in.
What AWS Actually Shipped: AgentCore Runtime v2
AgentCore first launched as AWS’s answer to a specific problem: agents that call tools, hold memory across turns, and run for minutes or hours don’t fit neatly into the request-response model that Lambda was built for. The original runtime worked, but cold starts were rough. AWS’s own published figures put v1 cold-start latency between 5.4 and 30 seconds depending on container image size, an eternity when a user is waiting on an agent to pick up a session.
Runtime v2 attacks that number directly. According to AWS’s release notes, p75 cold-start latency now lands between 1.9 and 2.0 seconds for images ranging from 200MB up to 2GB, a range that covers most production agent containers. That is a drop of roughly 90 percent off the high end of the old range, and it changes what kinds of agents are practical to run as ephemeral, scale-to-zero services rather than always-on processes that quietly burn compute budget overnight.
The architecture behind the improvement leans on microVM-based isolation paired with elastic memory management, the same lineage of technology AWS used to speed up Lambda’s own cold starts years earlier, now adapted for agents that need persistent state between invocations. Billing moved to a consumption model: $0.1276 per vCPU-hour and $0.0169 per GB-hour, so a team only pays for the seconds an agent is actually thinking, not for a reserved instance sitting idle between requests.
Why Cold Starts Were the Real Blocker
Cold start latency sounds like a minor engineering detail until an agent has to make it through a multi-step tool chain in real time. An agent that calls a database, reasons over the result, then calls an external API needs its runtime to be present and fast at every hop. A 30-second cold start on step one of five doesn’t just slow the interaction, it often blows past the timeout budget the calling application set for the whole session.
That’s also why the timing of two other AWS releases the same week matters. AWS extended Lambda’s function timeout to 90 minutes for asynchronous and event-source-mapping invocations running on Lambda Managed Instances, up from the previous 15-minute ceiling, a sixfold jump. Synchronous invocations still cap at 15 minutes, but the async path now supports agent workflows that legitimately need to chew on a task for an extended stretch: batch document analysis, long research chains, or multi-agent orchestration where one agent waits on another. AWS also pushed Amazon Quick Desktop to general availability on macOS and Windows, letting agents keep running after a user closes their laptop, with conversations synced back across devices once the user reconnects.
Strands Harness: An Open-Source Agent That Doesn’t Need AWS
Three days after Runtime v2 shipped, AWS released Strands Harness, an open-source AI agent framework built to run locally or across AWS, Google Cloud, Microsoft Azure, Modal, and Cloudflare. That is an unusual move for a hyperscaler: AWS is giving away tooling that works just as well on a competitor’s infrastructure as its own.
The logic isn’t charity. Strands Harness ships with read, write, edit, and shell access, web search, long-term memory across sessions, context management with file offloading, automated checklist delegation, and native Model Context Protocol server support. It can be pointed at Anthropic’s Claude models, OpenAI’s models, Amazon Bedrock, Google’s models, or a locally hosted Ollama instance. If a developer starts a project with Strands Harness on their laptop against a local model, then scales the same agent to Bedrock in production, AWS has captured that customer’s workload without ever forcing the choice.
AWS’s own benchmarking, published alongside the release, claims Strands Harness runs 26 percent more efficiently than competing frameworks using the same underlying model, and reports 77 percent lower token costs than Claude Code on identical tasks when both are run against Anthropic’s Fable 5 model. AWS also points to strong results on the Terminal Bench 2.1 benchmark, a suite that measures how well an agent completes real command-line tasks rather than answering trivia. Independent, third-party verification of those figures hadn’t landed as of this writing, so treat them as AWS’s own claim until outside benchmarks confirm or contest them.
Installation is deliberately low-friction:
# Install via pip
pip install strands-harness
# Or via npm
npm install -g strands-harness
# Point it at a local model and start an agent session
strands-harness --model ollama/llama3 --workspace ./projectGPT-6 Astra Arrives on Bedrock the Same Week
The infrastructure news didn’t happen in isolation. On September 14, 2026, AWS made OpenAI’s GPT-6 Astra generally available through Amazon Bedrock, giving AWS customers a managed route to what AWS itself describes as OpenAI’s most capable model to date. GPT-6 Astra supports up to 1 million input tokens and is pitched around deeper reasoning, professional-quality writing and design work, and advanced computer and browser use. Bedrock customers can call it through the standard Bedrock APIs, and AWS says inference data isn’t used to train the underlying model, a data-handling detail enterprise buyers tend to ask about before signing off.
Anthropic moved in the same window. Claude Opus 5.5 launched on September 22, 2026 and is available across Anthropic’s own API, AWS, Google Cloud, and Azure simultaneously, with typical running costs reported at 40 percent below Claude Opus 5. Between GPT-6 Astra landing on Bedrock and Claude Opus 5.5 shipping across all three major clouds on day one, the pattern is clear: model access is no longer a competitive moat for any single cloud. The moat, if there is one, has shifted to the runtime layer that executes agents built on top of those models, which is exactly the layer AWS just rebuilt.
The Cloud Agent Runtime Landscape in Late 2026
AWS is not moving into empty territory. Google’s Gemini Enterprise Agent Platform, the production successor to what was previously branded Vertex AI Agent Builder, reached production-grade status back in January 2026, giving Google roughly eight months of lead time on a live, SLA-backed agent runtime. Microsoft’s Azure AI Foundry Agent Service completed its rollout between July and August 2026, putting it in general availability only weeks before AWS’s Runtime v2 shipped. All three hyperscalers now offer production-ready agent runtimes backed by service-level agreements, which closes out a debate that ran through most of 2025 and early 2026 about whether cloud vendors would treat agents as first-class infrastructure at all.
| Platform | Production-Ready Since | Cross-Cloud Open-Source Framework | Billing Model |
|---|---|---|---|
| AWS AgentCore Runtime v2 | September 18, 2026 | Yes (Strands Harness) | $0.1276/vCPU-hr + $0.0169/GB-hr |
| Google Gemini Enterprise Agent Platform | January 2026 | No (Google-hosted) | Consumption-based, per Gemini Enterprise pricing |
| Azure AI Foundry Agent Service | July-August 2026 | No (Azure-hosted) | Consumption-based, per Foundry pricing |
The differentiator AWS is betting on isn’t raw model access, since Bedrock, Vertex AI, and Azure AI Foundry all now offer a broadly overlapping menu of third-party models. It’s runtime efficiency and portability. Google and Microsoft haven’t open-sourced a cross-cloud equivalent to Strands Harness, which means a developer who wants a framework that runs identically on a laptop and on three different clouds currently has one real option, and AWS built it.
AgentCore v2 Pricing, Broken Down
Consumption-based agent pricing is still new enough that most teams don’t have an intuition for what a workload will cost. The table below breaks the published AgentCore v2 rates into a few rough scenarios so engineering leads budgeting for an agent rollout have a starting point, though actual costs will vary heavily with memory footprint and how long each agent session stays warm.
| Workload Pattern | vCPU-Hours/Day | Memory (GB-Hours/Day) | Rough Daily Compute Cost |
|---|---|---|---|
| Light internal tool (few dozen sessions/day) | ~2 | ~4 | ~$0.32 |
| Customer-facing support agent (moderate traffic) | ~40 | ~80 | ~$6.45 |
| High-volume enterprise agent fleet | ~400 | ~800 | ~$64.56 |
Those figures are compute alone, based directly on AWS’s published $0.1276/vCPU-hour and $0.0169/GB-hour rates. They exclude model inference costs, data transfer, and any managed services an agent calls into, which for most production deployments will end up being the larger line item. Still, the scale-to-zero design means a lightly used internal agent genuinely costs pennies a day to keep available, a meaningful shift from the always-on EC2 instances teams used to reach for when they needed an agent that could respond at any hour.
Historical Context: From EC2 to Lambda to Agent Runtimes
AWS has rebuilt its compute abstraction roughly once a decade. EC2, launched in 2006, virtualized the server. Lambda, launched in 2014, virtualized the function. AgentCore, and now its v2 revision, is AWS’s attempt to virtualize the agent: a unit of compute that holds memory, calls tools, and runs for an unpredictable duration somewhere between a Lambda invocation and a long-lived EC2 process. Each of those earlier shifts took multiple point releases before the abstraction actually matched how developers wanted to build. Lambda’s own cold-start problem took years and several re-architectures to tame. AgentCore reaching a sub-two-second cold start in its second major version, less than a year after its debut, suggests AWS applied the Lambda lessons directly rather than relearning them from scratch.
What This Means for Cloud Spending and Vendor Choice
For finance and platform teams, the immediate impact is that “agent infrastructure” now has a real, comparable price tag across all three major clouds rather than being an unpredictable custom build on top of general-purpose compute. That matters for FinOps planning: a consumption-based, scale-to-zero agent runtime is a fundamentally different budgeting problem than a fleet of reserved GPU instances running inference around the clock. Teams that previously avoided agent deployments because the cost model was opaque now have published, comparable rates to model against.
The bigger strategic shift is that AWS open-sourcing Strands Harness weakens the traditional lock-in argument for choosing a cloud based on which agent framework a team adopts first. A framework that runs on Google Cloud and Azure just as well as it runs on AWS makes the runtime choice, rather than the framework choice, the thing that actually locks a workload to a vendor. That flips the negotiating leverage: platform teams can prototype anywhere and decide on a production home later, based on runtime cost and latency rather than which SDK they happened to start with.
Security and Governance Questions the Runtime Doesn’t Answer
None of this week’s releases directly addresses the governance questions that have followed agent infrastructure all year: what happens when an agent with shell access and long-term memory is compromised, how credentials get scoped when an agent calls a dozen internal tools, and how an incident response team traces what an autonomous agent actually did across a multi-hour session. AgentCore v2’s microVM isolation helps contain a single agent’s blast radius, and that’s a real improvement over shared-process models. But isolation at the runtime level doesn’t substitute for scoped IAM permissions, audit logging of tool calls, and rate limits on what an agent is allowed to touch. Security teams evaluating AgentCore v2 or Strands Harness for production use should treat the runtime improvements as necessary infrastructure, not as a finished security story.
What Developers Should Actually Do This Week
Teams already running agents on the original AgentCore runtime should benchmark their own cold-start numbers against the published v2 figures before migrating, since AWS’s 1.9-2.0 second figure is a p75 measurement, not a guaranteed floor, and real workloads with larger images or unusual dependency trees may land outside that range. Teams evaluating Strands Harness should pilot it against a narrow, well-understood task first, since AWS’s efficiency and cost claims haven’t yet been reproduced by an independent benchmark. And any team budgeting for a production agent rollout should model costs using the consumption rates above rather than assuming agent compute behaves like a standard EC2 or Lambda bill, because the usage patterns (long idle periods punctuated by bursts of tool-calling activity) don’t map cleanly onto either.
Predictions: Where Cloud Agent Infrastructure Goes Next
- Google and Microsoft will each publish their own open-source, cross-cloud agent framework within the next two quarters to answer Strands Harness, rather than cede the portability narrative to AWS.
- Independent benchmark firms will publish third-party verification (or rebuttal) of AWS’s 26 percent efficiency and 77 percent cost-reduction claims for Strands Harness within a few months, since claims that specific tend to draw scrutiny fast.
- Agent-specific IAM tooling, purpose-built for scoping what an autonomous agent can touch mid-session, becomes the next major AWS, Google, and Azure release cycle, following the same pattern where compute ships first and governance tooling catches up roughly two quarters later.
- Pricing pressure will push at least one hyperscaler to introduce a free or heavily discounted tier for low-volume agent runtimes by mid-2027, mirroring how Lambda’s free tier accelerated serverless adoption a decade earlier.
- Expect the next AgentCore point release to target sub-second cold starts, since AWS’s own trajectory from Runtime v1 to v2 shows it treats cold-start latency as the primary competitive metric against Google and Azure.
Competitive Comparison: Where Each Cloud Still Wins
AWS’s advantage right now is speed of iteration and the openness of Strands Harness. Google’s advantage is tenure: Gemini Enterprise Agent Platform has been production-grade since January 2026, giving it roughly two extra quarters of real customer feedback baked into its stability and tooling. Azure’s advantage is enterprise integration depth, particularly for organizations already standardized on Microsoft 365 and Entra ID, where AI Foundry Agent Service plugs into identity and compliance tooling that teams already operate. No single cloud has a clean sweep. A team picking a runtime today is really choosing between AWS’s raw performance numbers, Google’s longer production track record, and Azure’s identity and compliance integration, and the right answer depends more on where an organization’s existing infrastructure already lives than on any single benchmark.
Frequently Asked Questions
What is AWS AgentCore Runtime v2?
It’s AWS’s rebuilt infrastructure layer for running AI agents in production, released September 18, 2026. It uses microVM-based isolation and elastic memory management to cut cold-start latency to a p75 range of 1.9-2.0 seconds, down from 5.4-30 seconds on the original AgentCore runtime.
How much does AWS AgentCore v2 cost?
AWS bills AgentCore v2 at $0.1276 per vCPU-hour and $0.0169 per GB-hour on a consumption basis, with scale-to-zero support so idle agents don’t accrue compute charges. Model inference costs and any additional AWS services an agent calls are billed separately.
What is Strands Harness and is it free?
Strands Harness is AWS’s open-source AI agent framework, released September 21, 2026. It’s free to install via pip or npm and can run locally or be deployed to AWS, Google Cloud, Azure, Modal, or Cloudflare. It supports Claude, OpenAI, Bedrock, Google, and locally hosted Ollama models.
Does Strands Harness only work on AWS?
No. AWS built it specifically to run across multiple clouds and locally, unlike Google’s Gemini Enterprise Agent Platform or Microsoft’s Azure AI Foundry Agent Service, which are tied to their respective clouds.
How does AgentCore v2 compare to Google and Microsoft’s agent platforms?
Google’s Gemini Enterprise Agent Platform reached production-grade status in January 2026, ahead of AWS. Azure AI Foundry Agent Service completed rollout in July-August 2026. AgentCore v2 arrived most recently, on September 18, 2026, but is the only one of the three paired with an open-source, cross-cloud framework in Strands Harness.
What is the new AWS Lambda timeout limit for agents?
AWS extended Lambda’s timeout to 90 minutes for asynchronous and event-source-mapping invocations running on Lambda Managed Instances, up from the previous 15-minute cap, a sixfold increase. Synchronous invocations remain capped at 15 minutes.
Is GPT-6 Astra available through AWS?
Yes. OpenAI’s GPT-6 Astra became generally available on Amazon Bedrock on September 14, 2026, supporting up to 1 million input tokens and callable through standard Bedrock APIs.
Should my team migrate to AgentCore v2 right away?
Benchmark your own agent’s cold-start times against AWS’s published p75 figures before migrating production workloads, since results vary with container image size and dependencies. For new projects, AgentCore v2’s pricing model and lower latency make it a reasonable default to evaluate first.
