Enterprise workloads are getting bigger, more variable, and harder to predict, especially as agentic applications introduce spiky, unpredictable demand. Most data platforms weren't built for this reality—to cope with demand, they bolt AI services onto aging architecture, leaving customers to manage, monitor, and pay for multiple systems to get the job done. That fragmentation slows your teams down and limits how fast and how far your agentic applications can run.
In a traditional database architecture, storage is tied to the machine that runs your queries. Scaling up, adding a replica, or restoring a backup comes down to copying data from one machine to another, and the bigger the database, the longer that takes. My colleague Abhishek Chauhan calls this “storage gravity.” “Data doesn’t want to move,” he wrote for the MongoDB Engineering Blog. The bigger the data gets, the harder it pulls.
MongoDB built Atlas Infinite precisely for this reality; purpose-built to absorb spikes in demand with flexible, elastic scaling. Whether you’re launching a first prototype or running at petabyte-scale in production, Atlas Infinite enables you to build on a foundation that scales with you and never forces re-architecture. With MongoDB Search and Vector Search supported on Atlas Infinite in public preview, your database and retrieval live in one platform, with nothing to stitch together.
How Atlas Infinite works
A new deployment option within MongoDB Atlas, Atlas Infinite separates compute from storage so each scales independently and rapidly. Storage moves into a fully managed layer that handles replication, durability, and backup across availability zones, so compute no longer has to carry the data with it.
The impact is dramatic. Read replicas come online in minutes because there's no data to copy. A single shard holds up to 128 TB, so you no longer shard just to add disk space. You only pay for the data you store, not capacity provisioned in advance, so a small team never has to buy a bigger compute tier just to get more disk. And it’s all driven by the same MongoDB API, drivers, and tooling, so your application doesn’t need to change.
The separation of storage and compute matters most where agentic applications grow fastest: the retrieval layer. Every answer an assistant gives and every step an agent takes starts with a search over your data, and the data behind that search, especially vector embeddings, can grow large quickly. With MongoDB Search and Vector Search running natively on Atlas Infinite, that data lives on the same foundation as the rest of your application and can grow without re-architecture. Build your agentic workload once and keep scaling it on the same foundation as demand grows.
Figure 1. Compute and storage as independent layers in Atlas Infinite.
Retrieval, built into the database
Many retrieval stacks are cobbled together from disconnected components—a database, a search engine, and a vector database—which means running all of those separate parts, plus managing the pipelines that keep everything in sync. On Atlas Infinite, retrieval is part of the platform, so there are fewer pieces to build, secure, and maintain. Here is what that looks like:
- One platform, nothing to stitch together: On Atlas Infinite, your database and retrieval work together seamlessly, with no separate search engine or vector database to stand up, sync, or monitor. MongoDB Atlas keeps your indexes in sync with your data automatically, so there is no pipeline for your team to build or maintain, and no extra systems to copy sensitive data into or secure. With Atlas Infinite, retrieval is built in, alongside the ability to scale to absorb unpredictable demand with zero waste.
- Start small, never outgrow your data platform: A team can start with a 5GB prototype that includes semantic search and keep building on the same foundation. Rather than sizing and maintaining two infrastructures, storage grows automatically with your data, billed only for what you store. The operational data behind your search has room to grow to petabyte scale on Atlas Infinite, with no re-platforming when the application takes off.
- Agent memory and context retrieval: Give agents one place to store and retrieve context, history, and state alongside your operational data. Support thousands of agents hitting your retrieval layer while also persisting agent memory and context within a single, durable system that scales when they need it.
Figure 2. Search and Vector Search run alongside the database on Atlas Infinite, with indexes kept in sync automatically and data stored once in Atlas-managed storage.

How Atlas Infinite handles your largest text and vector workloads
Separating compute from storage in the database also changes the scaling behavior and economics of large retrieval workloads. Text and vector data lives in the database first, where it drives storage requirements. Because Atlas Infinite manages that storage separately from compute, the economics come down to one property of the data: how well it compresses.
Databases shrink data on disk with compression, which works by finding repetition. Text is full of repetition: common words, repeated field names, predictable structure. Text in MongoDB typically compresses to about 40% of its original size. An embedding is an array of decimal values with almost no repetition, so it shrinks by only about 13%. In practice, a vector takes up as much space on disk as it does in your application.
How each deployment option stores that data
Atlas Core uses attached storage volumes. Each node in a replica set keeps a full copy of the data on its own disk, provisioned ahead of time with room to grow, and compute and storage come in matched tiers. That gives every node complete isolation and predictable performance, and it's the right fit for many workloads, especially ones where data and query load grow together.
Vector workloads tend to be storage-driven because high-dimension embeddings are so large. A RAG knowledge base can hold hundreds of gigabytes of embeddings, which drives up storage needs relative to query volume. On Atlas Core, storage can drive scaling decisions: once you outgrow a tier’s maximum disk size, you have to move up a tier to get more storage, even if you don’t need more compute, and very large datasets eventually call for sharding.
On Atlas Infinite, compute and storage scale independently. Storage is billed per logical (uncompressed) GB of data you store, metered hourly. Replication across availability zones happens inside the storage layer and isn't billed separately. There's no headroom to provision, and because a shard holds up to 128 TB, a growing dataset doesn't push you to a larger compute tier or to more shards. Because embeddings barely compress, their logical size and their size on disk are nearly the same, so you pay only for the data you store and nothing for the copies and headroom underneath it. As vector collections grow to hundreds of millions of documents, that billing model becomes an advantage.
Here is an example. For a collection with 100 million documents, each with a 1,024-dimension float32 embedding and about 1 KB of other fields, storage is roughly 500 GB uncompressed. Assuming moderate query traffic, an M30 cluster tier’s compute is sufficient.
On Atlas Core, since embeddings barely compress, the data shrinks to ~435GB on disk. Each node also needs space for the oplog and room for the collection to grow. At 1.3× headroom, that comes to about 565 GB per node, more than the 512 GB an M30 supports, so the cluster has to move up to an M40 for the disk. On Atlas Infinite, the cluster stays at the compute tier its queries need, and storage is billed once on the 500 GB it holds. With storage billed once and no tier-up for disk, the total monthly cost of this deployment, Search Nodes included, comes out about 25% lower than on Core. At 1 billion vectors (about 5 TB), it is about 30% lower, and the gap keeps widening as vector data grows. These figures are modeled on list prices in US East, with Search Nodes sized to the smallest tier that fits the index, so your results will vary.
Where the difference is smaller
Text-heavy search workloads also see a TCO benefit on Atlas Infinite, around 5% to 10% cost reduction at multi-terabyte scale. Text compresses well, so Core's storage cost per GB is already low. The advantage of Atlas Infinite comes from deferring early tier-ups and delaying sharding for disk. Under 500 GB, the two deployment options are roughly even on cost, so a smaller workload gets Atlas Infinite’s room to grow without paying more for it. Choose the deployment option based on the elasticity and growth you expect.
Get started with Search and Vector Search on Atlas Infinite
MongoDB Search and Vector Search are available on Atlas Infinite in public preview on AWS. Choose Atlas Infinite as the deployment option for your next workload, add a search index the way you would on Atlas Core, and keep building on the same foundation as your application grows. Whether you’re prototyping an AI feature or running a large production application, you can start small and keep going. Start with the Atlas Infinite documentation.