Amazon Web Services spent the first two weeks of August 2026 rewriting the playbook for how enterprises build AI agents in the cloud. On August 5, AWS pushed native vector search in DynamoDB to general availability. Five days later, it followed up with generally available runtime instances for Bedrock AgentCore, web search access baked directly into Bedrock, and a fresh set of OpenAI models running on AWS silicon. Together, the releases mark the clearest signal yet that AWS wants agentic AI workloads to live and die inside its own stack, not bolted on top of a third-party vector database or a rented GPU cluster somewhere else.

The keyword aws bedrock agentcore now pulls roughly 880 monthly searches in the US with low ad competition, according to DataForSEO keyword data pulled this week, and the interest is easy to explain. Engineering teams that spent 2024 and 2025 duct-taping Pinecone or Weaviate onto their AWS pipelines suddenly have a native option that promises to cut a whole tier out of the architecture. This piece breaks down what actually shipped, what it costs, how it stacks up against Azure and Google Cloud, and where the FinOps math lands for teams deciding whether to move.

What AWS Just Shipped: AgentCore Runtime Instances Explained

Bedrock AgentCore runtime instances give developers dedicated, persistent EC2-backed compute for running production AI agents, instead of the shared, ephemeral execution model AgentCore launched with in preview. That distinction matters more than it sounds. Shared execution environments reset agent state between invocations, which is fine for a single-turn chatbot but breaks down fast for anything that needs memory across a long research task or a multi-agent handoff.

Runtime instances support sessions that run for up to 14 days, GPU acceleration for models that need it, and coordination between multiple agents working the same task. AWS is positioning this as the infrastructure layer under agentic workflows the way EC2 sat under web apps for two decades: a persistent, controllable unit of compute that developers can size, monitor, and pay for on a predictable basis rather than guessing at shared-tenancy pricing.

For teams that tried building long-running agents on the original AgentCore preview, the complaint was consistent: state management was the hard part, not the model calls. Runtime instances answer that directly by giving each agent (or agent swarm) a machine that stays alive between steps instead of forcing developers to serialize everything to an external store just to survive a cold start.

DynamoDB Native Vector Search Goes GA

The bigger architectural shift, at least by search volume and developer chatter, is DynamoDB’s native vector search, which AWS confirmed as generally available on August 5, 2026. Embeddings now live as an attribute on the same item as the rest of your operational data. Query them with a SearchVectors call against a vector index defined on that attribute, and you get semantic retrieval without standing up a second database.

That single-table approach is the whole pitch. Teams running product catalogs, user profiles, or agent memory in DynamoDB no longer have to sync a subset of that data into Pinecone, Weaviate, or OpenSearch just to run a similarity search. AWS is quoting single-digit millisecond latency and recall at or above 99%, figures pulled straight from the AWS Database Blog’s own benchmarking of the feature.

The catch: DynamoDB vector search inherits DynamoDB’s own constraints. It scales beautifully for point lookups and item-scoped searches, but it is not a drop-in replacement for a purpose-built vector database doing large-scale approximate nearest neighbor search across billions of unrelated vectors. For agent memory, session context, and per-user retrieval, the tradeoff favors DynamoDB. For a general-purpose semantic search engine over a massive shared corpus, teams will likely still reach for OpenSearch or a dedicated vector store.

A Sample Query Against the New Vector Index

The basic pattern for a semantic lookup against a DynamoDB table with a vector index looks like this in boto3:

import boto3

client = boto3.client("dynamodb")

response = client.search_vectors(
    TableName="agent-memory",
    IndexName="memory-embedding-index",
    QueryVector={"FloatVector": query_embedding},
    TopK=10,
    Filter={
        "AttributeExists": {"Path": "session_id"}
    }
)

for item in response["Items"]:
    print(item["content"], item["score"])

No separate ingestion pipeline, no second set of IAM permissions for a vector store, no drift between the operational record and its embedding. That simplicity is exactly why teams are searching for this feature by name rather than waiting to read about it in a release-notes digest.

GPT-5.6 Sol, Terra, and Luna Land on Bedrock

AWS paired the infrastructure news with a model lineup update. OpenAI’s GPT-5.6 family, three models, Sol, Terra, and Luna, is now available on Bedrock through a Responses API, running on what AWS calls a next-generation inference engine tuned for latency and reliability. Sol targets deep reasoning tasks, Terra is the balanced middle tier for general agent work, and Luna is built for high-volume, cost-sensitive inference.

Having all three tiers inside Bedrock means teams can route a single agent workflow across models based on task complexity, keeping the expensive reasoning model for planning steps and pushing routine tool calls to the cheaper tier, all without leaving AWS’s IAM and billing boundary. That routing flexibility is a big part of why AgentCore and the DynamoDB changes landed together instead of as separate announcements. AWS is selling a full stack, not a single feature.

AWS Cuts Bedrock Pricing by Up to 80%

On July 30, 2026, AWS cut on-demand inference pricing for GPT-5.6 Luna on Bedrock by as much as 80%, with GPT-5.6 Terra pricing down roughly 20%. For teams running high-volume agent workloads, that changes the FinOps math significantly. A workload that looked cost-prohibitive on Bedrock in June suddenly clears budget review in August, and that timing lines up neatly with the AgentCore and DynamoDB launches. Cheaper inference plus native vector search plus dedicated runtime compute is a package deal aimed squarely at teams currently running agent stacks on a mix of vendors.

ModelBest ForAccessPricing Change (Jul 30, 2026)
GPT-5.6 SolAdvanced reasoning, planning stepsBedrock Responses APINot discounted
GPT-5.6 TerraBalanced general-purpose agent tasksBedrock Responses API~20% lower on-demand
GPT-5.6 LunaHigh-volume, cost-sensitive inferenceBedrock Responses APIUp to 80% lower on-demand

FinOps Gets a New Lever: Cost Allocation by IAM Principal

Alongside the pricing cuts, AWS added cost allocation by IAM principal on the bedrock-mantle endpoint, letting finance and platform teams attribute inference spend down to the individual user or role making the call. For any organization running Bedrock across multiple product teams, that closes a gap that has quietly frustrated FinOps practitioners since Bedrock launched: usage dashboards existed, but attributing a spike to a specific team without custom logging was clunky at best.

Chargeback and showback models depend on being able to draw a line from a dollar spent to a team responsible for spending it. IAM-principal-level attribution gives platform teams that line for free, which matters more as agent workloads scale from a handful of pilot projects to dozens of production agents running continuously across an org.

Why AWS Is Racing to Own the Agent Stack

None of this happened in isolation. Gartner forecasts worldwide AI-optimized infrastructure-as-a-service spending will grow 96% in 2026 to reach $42 billion, with the market expected to hit $66 billion in 2027, according to Gartner’s most recent IaaS forecast covered by CIO Dive. Inference spending alone is projected to hit $23.3 billion in 2026, edging past training spend of $19 billion for the first time. AI infrastructure broadly, spanning optimized IaaS, servers, network fabric, and chips, will account for more than 45% of total AI spending this year.

Enterprises are on track to add roughly $6 billion in new spending on generative AI models and agents in 2026 alone. Every hyperscaler wants a bigger slice of that number, and AWS’s bet is that owning the full path from vector storage to agent runtime to inference pricing keeps customers from splitting their spend across three or four vendors. A team that starts with DynamoDB for operational data has much less reason to open a Pinecone account once vector search lives in the same table.

Competitive Landscape: How Azure and Google Cloud Respond

AWS is not the only hyperscaler chasing this workload. Azure has leaned on Cosmos DB’s integrated vector search and Azure AI Foundry’s agent orchestration tools, while Google Cloud has pushed AlloyDB’s native pgvector support and Vertex AI Agent Builder as its answer to the same problem. The difference right now is timing and integration depth. AWS shipped AgentCore runtime instances, DynamoDB vector search, and Bedrock model routing within the same two-week window, giving it a coordinated launch story that Azure and Google Cloud have not matched with a single announcement of comparable scope this quarter.

CapabilityAWSAzureGoogle Cloud
Native vector search in operational DBDynamoDB (GA Aug 5, 2026)Cosmos DB integrated vector searchAlloyDB with pgvector
Managed agent runtimeBedrock AgentCore runtime instancesAzure AI Foundry Agent ServiceVertex AI Agent Builder
Third-party frontier models on-platformOpenAI GPT-5.6 family via BedrockOpenAI models via Azure OpenAI ServiceAnthropic and partner models via Vertex
Recent pricing moveUp to 80% cut on Luna tier (Jul 30, 2026)No comparable cut announced this quarterNo comparable cut announced this quarter

The practical takeaway for engineering leads: the choice between clouds for agent workloads is increasingly a choice about which vendor already holds your operational data. Migrating a DynamoDB-heavy application’s semantic search needs to AWS’s own vector index is a much smaller lift than exporting embeddings to a separate cloud’s agent platform.

The Shift From Bedrock Agents to AgentCore

AWS also quietly moved the original Bedrock Agents feature into what it now calls Bedrock Agents Classic, placing it in maintenance mode as of early July 2026. Portions of SageMaker AI’s older feature set and AWS Managed Services Advanced received the same treatment. The message is not subtle: AWS wants new agent development happening on AgentCore, and it is willing to sunset the tooling that got customers through 2024 and 2025 to make that happen.

Teams still running production workloads on the original Bedrock Agents framework should treat this as a migration signal rather than an emergency. Maintenance mode typically means security patches continue while new features stop, giving most teams a realistic runway to plan a move to AgentCore rather than a forced cutover.

Legacy Search Infrastructure Gets a Longer Runway

Not every older service is being pushed out the door immediately. AWS extended security and OS patch coverage for legacy Elasticsearch and OpenSearch engine versions out to November 7, 2027, giving enterprises running older search clusters more than a year to plan a move toward newer, vector-centric architectures without an urgent patching cliff. AWS also raised the per-collection-group limit on OpenSearch Serverless’s next-generation engine from 1,500 to 10,000 collections, a change aimed squarely at large multi-tenant observability and search deployments that were bumping against the old ceiling.

Lambda’s Code Storage Limit Disappears

A smaller but genuinely useful change shipped in July 2026: AWS Lambda now supports self-managed code storage, letting functions reference source code directly from a customer-owned S3 bucket instead of going through Lambda’s internal copy step. That removes Lambda’s historical code storage ceiling and speeds up activation time right after a deployment, since there is no longer an internal copy operation sitting between a code push and the function being ready to invoke.

It is a niche fix compared to the agent and vector search news, but it matters for exactly the kind of large, dependency-heavy agent functions AgentCore and Bedrock are pushing developers to build. An agent packaged with a large toolset or model client library was one of the more common places teams hit Lambda’s old storage limits.

Historical Context: From RAG Pipelines to Native Vector Databases

Retrieval-augmented generation architectures spent the last three years converging on a fairly standard pattern: an application database for operational data, a separate vector database for embeddings, and a sync job stitching the two together. Pinecone, Weaviate, and Qdrant built entire businesses on being that dedicated vector layer, and for good reason. Early on, no major cloud database supported vector search natively, so a standalone product was the only path to production.

That started changing in 2024 as Postgres extensions like pgvector matured and cloud providers began bolting vector indexes onto existing managed databases. DynamoDB’s move to native vector search is the logical next step in that consolidation, following a similar trajectory to how MongoDB Atlas and Redis added vector capabilities to their own core products rather than ceding that layer to a separate vendor. What is different this time is the pairing with a dedicated agent runtime. AWS is not just adding a feature to a database, it is trying to own the entire path from stored data to agent action.

Security and Governance Considerations

Persistent agent runtimes that stay alive for up to 14 days raise governance questions that ephemeral, single-invocation functions never had to answer. A compromised long-running agent session has a much bigger blast radius than a Lambda function that resets every few seconds. Security teams evaluating AgentCore runtime instances should treat them the same way they would a long-lived EC2 instance: scoped IAM roles, session timeout policies, and active monitoring for anomalous tool calls, not the lighter-touch review that a stateless function might get.

Web search on Bedrock, now generally available, adds another wrinkle. Giving an agent direct, governed access to the open web is convenient, but it also means prompt injection risk moves from a theoretical concern to something security teams need to actively test for, especially on agents with write access to production systems. AWS frames this as a governed capability rather than an open scraping tool, but the governance still sits on the customer’s side of the shared responsibility line.

Market Impact: What This Means for Cloud Spending Decisions

For platform teams currently budgeting cloud spend for 2027, this round of releases changes the calculus in a few concrete ways. First, the case for a standalone vector database gets weaker for any workload where the source data already lives in DynamoDB, since removing that extra hop cuts both latency and a line item from the infrastructure bill. Second, the Bedrock pricing cuts make it cheaper to experiment with high-volume agent workloads that would have blown a pilot budget in June. Third, IAM-principal-level cost attribution gives finance teams a real answer to “which team is driving this Bedrock bill” without custom tooling.

None of that guarantees AWS wins the agent infrastructure race outright. Azure and Google Cloud both have credible, if less tightly bundled, answers. But the coordinated nature of this release, four major changes shipped inside ten days, suggests AWS product teams are working from a shared roadmap aimed at reducing the number of vendors a customer needs to touch to ship a production agent.

Five Predictions for the Next Two Quarters

  • Vector database vendors respond with cloud-native integrations. Expect Pinecone and Weaviate to push harder on hybrid deployment options that sit closer to a customer’s existing cloud database rather than competing purely on standalone performance.
  • Azure and Google Cloud ship comparable pricing cuts within two quarters. AWS’s 80% cut on Luna-tier inference sets a new floor that competitors will need to match to stay in consideration for high-volume agent deals.
  • Bedrock Agents Classic migrations become a recurring support topic. Teams that built on the original Agents framework will spend the next several months planning moves to AgentCore, generating a wave of migration guides and consulting engagements.
  • DynamoDB vector search adoption concentrates in agent memory use cases first. The clearest early wins will be session memory and per-user retrieval rather than large-scale shared-corpus search, where dedicated vector databases still have an edge.
  • FinOps tooling vendors add AgentCore and Bedrock-specific cost dashboards. Now that AWS exposes IAM-principal-level attribution, expect CloudHealth, Vantage, and similar platforms to build agent-spend-specific views on top of that data within the next two quarters.

Frequently Asked Questions

What is Amazon Bedrock AgentCore?
Bedrock AgentCore is AWS’s managed platform for building, deploying, and running AI agents. Its runtime instances, now generally available, give agents dedicated, persistent compute instead of shared, ephemeral execution, with sessions that can run for up to 14 days.

When did DynamoDB vector search become generally available?
AWS made native vector search in DynamoDB generally available on August 5, 2026, letting developers store embeddings as an attribute on existing items and query them with a SearchVectors call.

Do I still need a separate vector database like Pinecone or Weaviate?
For agent memory and per-user or per-session retrieval where the source data already lives in DynamoDB, native vector search likely removes the need for a separate store. For large-scale semantic search across a massive shared corpus, a dedicated vector database or OpenSearch still tends to perform better.

How much cheaper is Bedrock after the July 2026 pricing change?
AWS cut on-demand inference pricing for GPT-5.6 Luna by up to 80% and for GPT-5.6 Terra by roughly 20%, effective July 30, 2026. GPT-5.6 Sol pricing was not discounted in this round.

What happened to the original Bedrock Agents feature?
AWS moved it into maintenance mode as Bedrock Agents Classic in early July 2026, signaling that new development should move to AgentCore while existing Bedrock Agents workloads continue to receive security patches.

Does this affect Lambda functions too?
Indirectly. AWS Lambda added self-managed code storage from customer-owned S3 buckets in July 2026, removing Lambda’s old code storage limits, which helps larger agent functions that bundle sizable toolsets or model client libraries.

How does this compare to what Azure and Google Cloud offer?
Azure offers vector search through Cosmos DB and agent orchestration through Azure AI Foundry. Google Cloud offers AlloyDB with pgvector and Vertex AI Agent Builder. AWS’s advantage right now is timing: it shipped runtime instances, native vector search, and model pricing cuts within the same two-week window.

Is agentic AI infrastructure spending actually growing that fast?
Gartner forecasts worldwide AI-optimized IaaS spending will grow 96% in 2026 to $42 billion, reaching an estimated $66 billion in 2027, with inference spending ($23.3 billion) surpassing training spending ($19 billion) for the first time this year.

For more cloud computing coverage, visit the Cloud Computing section.

Sources: AWS Weekly Roundup, August 10, 2026, AWS Database Blog: native vector support in DynamoDB, Amazon Bedrock AgentCore product page, AWS Builder Center: hybrid retrieval with Bedrock and DynamoDB, DEV Community: building a semantic search agent on DynamoDB, and CIO Dive coverage of Gartner’s 2026 AI spending forecast.