# MongoDB (Atlas + Enterprise Advanced + Community + Voyage AI) — 4+1 Layer AI Infrastructure Assessment

> Mapped to the 4+1 Layer AI Infrastructure Model  
> Version: v1.0 - 4+1 v2: Authority Split · Date: September 5, 2026  
> Source: MongoDB documentation (Atlas, Vector Search and Search including the Automated Embedding overview and the self-managed compatibility and limitations pages, Atlas Stream Processing, MCP Server overview, tools, and access models, Atlas App Connections and Manage AI Client Access, Atlas Resource Policies, cluster auto-scaling, Search Nodes, Atlas Triggers and Functions, Relational Migrator getting-started and release notes, MongoDB Controllers for Kubernetes, Kafka Connector, Data Federation and Online Archive, Charts, LangGraph integration); MongoDB.local Build Fest releases (August 13, 2026: Atlas Managed MCP Server, App Connections, native coding-tool connectors; Atlas Embedding and Reranking API, voyage-code-4, vector search in Stream Processing); Voyage 4 model family and marketplace availability (January 15, 2026) and the voyage-4-nano Hugging Face card (Apache 2.0); MongoDB Search and Vector Search self-managed GA (July 1, 2026); native reranking public preview (June 2026); MongoDB MCP Server repository (Apache 2.0) and winter 2026 post; Enterprise Advanced product page; SSPL FAQ; Application Modernization Platform (September 16, 2025); intelligent assistant in Compass and Data Explorer GA (January 15, 2026); MongoDB fiscal 2026 annual report (Atlas 73%, Enterprise Advanced 20%, services 3% of revenue) and Q2 fiscal 2027 results. Peer-reviewed cell by cell through the labs claims ledger (mongodb-<layer>-chatgpt, ChatGPT gpt-5.5) and as a whole row by Antigravity (mongodb-row-agy); totals and escalated items in labs/reviews/mongodb-judgment.md.  
> Published by: The CTO Advisor LLC (DBA The Advisor Bench) · thectoadvisor.com  
> Author: Keith Townsend

[Full interactive assessment](https://layer2c.com/assessment/mongodb) · [Methodology](https://layer2c.com/methodology) · [What Is Layer 2C?](https://layer2c.com/what-is-layer-2c)

## Executive Summary

MongoDB is the operational database with the retrieval layer built in, and the map reads it as a data platform whose AI story stops at the store. One layer strong (1B: native hybrid retrieval plus the Voyage models, managed or self-run), five moderate (1A as a system of record without a catalog, 1C for streams and change data capture (CDC) into and out of MongoDB, 2A for cluster autoscaling and operators, 2B for embedding inference and a Model Context Protocol (MCP) tool surface with no model serving or agent runtime, Layer 3 for developer tooling and Charts), and two gaps where the substrate is a hyperscaler's or the enterprise's own and the reasoning plane is whoever's agent platform calls MongoDB.

The capture is coupled and mostly visible, and it turns on one license question. Atlas was 73% of fiscal 2026 revenue, Enterprise Advanced 20%, and the same engine runs on all three paths; what the enterprise can run itself is source under the Server Side Public License (SSPL), which isn't open source by the Open Source Initiative's definition but is possessed and operated without MongoDB. Read as Retained on the self-run seam (the reading written here, escalated), the row carries Retained 6, Delegated 2, Ceded 17 across 25 components: the engine, its retrieval core, change streams, and three Apache 2.0 pieces (the Kafka Connector, the Kubernetes operator, the MCP Server) lift, and Atlas is a managed service the enterprise can substitute with its own deployment. Read as source-available and Ceded, four chips flip and Atlas with them. Either way the Voyage embedding space is captive under the carve-out wherever the vectors are made, and the Atlas-only surfaces (Stream Processing, Search Nodes, Triggers, Resource Policies, Charts) rebuild nowhere.

The buyer's trade: governed retrieval next to the system of record, with frontier embedding and reranking a stage away and the whole engine runnable on-premises, in exchange for a retrieval model space that doesn't leave, a movement layer whose destinations are MongoDB, Kafka, and object storage, and no runtime above the database. Two surfaces are ahead of their badges: Automated Embeddings is generally available in the release and Preview in the docs, and native reranking is in public preview, so both sit in notes. What would move a cell: an agent runtime or model serving (2B), a governance catalog (1A), or the programmatic MCP configurations (agents as service accounts with their own roles) being read as an agent-identity leg at 2C, which is escalated. The reasoning plane, on MongoDB's own account, is bring your own.

## Layer Status

| Layer | Status | Classification |
|---|---|---|
| Layer 0 · Compute | ○ Not MongoDB's Layer (By Design); Atlas Rides the Hyperscalers, Enterprise Advanced Rides Yours | Compute & Network Fabric |
| Layer 1A · Storage | ◑ Operational System of Record + Access Governance; No Catalog, No Lineage | Data Storage & Governance |
| Layer 1B · Retrieval | ● Native Hybrid Retrieval + Voyage Models Inside the Database, Managed or Self-Run | Context Management & Retrieval |
| Layer 1C · Pipelines | ◑ Streams and CDC Into and Out of MongoDB; No Lineage, Fixed Destinations | Data Movement & Pipelines |
| Layer 2A · Orchestration | ◑ Cluster Autoscaling, Operators, and Ops Manager; No GPU Plane | Infrastructure Orchestration |
| Layer 2B · Runtime | ◑ Embedding Inference + MCP Tool Surface + Triggers; No LLM Serving, No Agent Runtime | Application Runtime & Execution |
| Layer 2C · Reasoning | ○ Governed Agent Access to MongoDB (App Connections, MCP Configurations), Not a Reasoning Plane | Agentic Infrastructure — The Reasoning Plane |
| Layer 3 (+1) · Applications | ◑ Developer-Tooling and Analytics Value Plane, MongoDB-Bound; No Business Applications | AI Application Layer — The Value Plane |

## DAPM Portability Profile (components)

| Classification | Count | Meaning |
|---|---|---|
| Retained | 6 | I possess the capability and can operate it independently of this provider |
| Delegated | 2 | Someone else provides the capability, but I can substitute that provider without reconstructing my accumulated opinions |
| Ceded | 17 | Changing providers requires reconstructing those opinions |

**Decision authority (per layer, gaps included)**

| Reading | Layers | Meaning |
|---|---|---|
| Retained | 1 | The enterprise, or code it writes or controls, decides |
| Delegated | 3 | Vendor or model decides; the enterprise can see and override |
| Ceded | 2 | Vendor or model decides; no override, often invisible |
| Absent | 2 | Nothing offered, nothing inherited |

## Strongest Layers

- **Layer 1B** (Context Management & Retrieval) — Native Hybrid Retrieval + Voyage Models Inside the Database, Managed or Self-Run

## Gap Areas

- **Layer 0** (Compute & Network Fabric) — Not MongoDB's Layer (By Design); Atlas Rides the Hyperscalers, Enterprise Advanced Rides Yours
- **Layer 2C** (Agentic Infrastructure — The Reasoning Plane) — Governed Agent Access to MongoDB (App Connections, MCP Configurations), Not a Reasoning Plane

## Layer-by-Layer Detail

### ○ Layer 0 · Compute: Compute & Network Fabric

*Raw compute, networking, and acceleration fabric*  
**Status:** Not MongoDB's Layer (By Design); Atlas Rides the Hyperscalers, Enterprise Advanced Rides Yours

**Decision authority:** Absent (decides: absent; visible: n/a; overridable: n/a; boundary: vendor)

**Gap Analysis:** MongoDB sells no silicon, fabric, or arrays. Atlas (generally available, GA, throughout) runs on Amazon Web Services (AWS), Azure, and Google Cloud in well over a hundred regions with the customer choosing provider and region, and a single cluster can span clouds; Enterprise Advanced and Community Edition run on whatever the enterprise owns, on bare metal, virtual machines, or Kubernetes through MongoDB Controllers for Kubernetes, with the customer supplying compute, storage, and networking. The revenue mix for fiscal 2026 (year ended January 31, 2026) was Atlas 73%, Enterprise Advanced 20%, and professional services 3%: most of the money takes the path where the substrate is a hyperscaler's, chosen through MongoDB and never administered by the customer, and a fifth of it takes the path where the substrate is the enterprise's own. Search Nodes, the dedicated infrastructure for Search and Vector Search on Atlas, are MongoDB-sized instances the customer picks a tier for, not compute the customer owns.

The exposure test governs on the Atlas path: a fleet the vendor rents and operates behind its service isn't a customer-administered substrate. On the self-managed path the substrate is the enterprise's own.

Calibration: the instrument grades what an architect can deploy, not what customers happen to consume (rule 7), and MongoDB has first-party hosted and self-managed production paths the way Elastic does. Elastic reads gap with authority Absent and names its cloud path as Ceded-invisible; Snowflake and Databricks read Ceded because they have no self-managed path. MongoDB is the Elastic case. Gap, Absent, with Atlas named as Ceded-invisible for the customers who take it.

**Borrowed Judgment:** None on the self-managed path: the enterprise supplies and operates the hardware or cloud account. On the Atlas path customers inherit MongoDB's choices of instance family, storage class, and placement inside the chosen region, visible only as a cluster tier, and the hosted Voyage inference fleet is inherited invisibly on both paths. Absent, the Elastic reading for a vendor with a real self-managed base.

### ◑ Layer 1A · Storage: Data Storage & Governance

*Durable, governed data foundation — the Governance Catalog that Layer 2C queries*  
**Status:** Operational System of Record + Access Governance; No Catalog, No Lineage

**Decision authority:** Delegated (decides: vendor; visible: true; overridable: true; boundary: vendor)

**MongoDB Community Server, Self-Run (SSPL Source)** [DAPM: Retained]  
The document database the enterprise runs itself on its own infrastructure. Source-available under the SSPL rather than an OSI license, but possessed and operated independently of MongoDB, with the copyleft trigger reserved for offering it as a service. Written Retained on the self-run seam, escalated to Keith.

**MongoDB Atlas (Managed Multi-Cloud Store: Backup, Point-in-Time Restore, Global Clusters)** [DAPM: Delegated]  
The managed database on AWS, Azure, and Google Cloud with continuous backup, restore, and region placement. The same engine the enterprise can run itself, so the managed service is substitutable at the cost of its conveniences: Delegated, the Elastic Cloud Hosted reading, contingent on the SSPL ruling.

**MongoDB Enterprise Server + Ops Manager (Enterprise Advanced)** [DAPM: Ceded]  
The commercially licensed server with the in-memory engine, self-managed auditing, Kerberos, and LDAP, managed through Ops Manager. Proprietary features on a subscription: Ceded.

**Queryable Encryption + RBAC + Client-Side Field-Level Encryption + Auditing** [DAPM: Ceded]  
Expressive queries over encrypted fields with keys that never leave the client, plus role-based access, client-side field-level encryption, and audit logging. MongoDB's encryption scheme; the keys are the customer's, the query capability isn't. Ceded.

**Atlas Resource Policies (Cedar) + Online Archive + Data Federation Tiering** [DAPM: Ceded]  
Organization-wide policies constraining cluster configuration in the Cedar policy language, and automatic tiering of cold data to object storage queryable through Data Federation. Atlas-only control and tiering surfaces: Ceded.

**Gap Analysis:** MongoDB is the durable store for the applications most enterprises build, and the same document database runs on three paths: Atlas (managed, multi-cloud, with continuous backup, point-in-time restore, Global Clusters for placing data by region, and Online Archive tiering to object storage), Enterprise Advanced (self-managed with the Enterprise Server, Ops Manager, and the in-memory engine, auditing, Kerberos, and Lightweight Directory Access Protocol (LDAP) integration the Community build lacks), and Community Edition under the Server Side Public License (SSPL). Governance is real at the access layer: role-based access control (RBAC), client-side field-level encryption, Queryable Encryption (expressive queries over encrypted fields without the server ever seeing plaintext or keys, expanded in 8.0), auditing, and Atlas Resource Policies (organization-wide guardrails on cluster configuration written in the Cedar policy language, with activity-feed events on every change). The buyer gets an operational system of record with the finest-grained encryption story among the database rows.

What's missing is the layer's other half. There's no governance catalog: no asset inventory, lineage, classification, or policy engine over the data that Layer 2C could query, the way Unity Catalog or Horizon govern their estates. Governance here is access control on a database, not a catalog over a data estate.

Calibration: Snowflake and Databricks read strong on governed lakehouses with catalogs; Elastic reads moderate on a tiered store with the map's finest access control and no catalog. MongoDB is the Elastic case with a system-of-record's durability and Queryable Encryption. Moderate.

**Borrowed Judgment:** Split by path, and the split rests on an escalated ruling. Community Edition self-run is source the enterprise possesses and operates without MongoDB; the SSPL isn't an Open Source Initiative (OSI) license, and its copyleft obligation bites only when the software is offered as a service to others, which an enterprise running its own database doesn't do. Written Retained on the self-run seam pending Keith's ruling on whether SSPL source qualifies. Atlas is then a managed service the enterprise can substitute with its own deployment of the same engine: Delegated, the Elastic Cloud Hosted reading (the wire-protocol implementations from other vendors are incomplete and aren't relied on). The Enterprise Server, Queryable Encryption, Online Archive, and Resource Policies are MongoDB's and Ceded. The runtime tradeoff is MongoDB's engine executing schemas, indexes, and access rules the enterprise wrote, with every knob exposed: vendor decides, visible, overridable, Delegated.

### ● Layer 1B · Retrieval: Context Management & Retrieval

*Low-latency retrieval for RAG — vector/hybrid search, context windows*  
**Status:** Native Hybrid Retrieval + Voyage Models Inside the Database, Managed or Self-Run

**Decision authority:** Delegated (decides: vendor; visible: true; overridable: true; boundary: vendor)

**Search + Vector Search Core, Self-Run (Community, mongot, MongoDB 8.3.4+, SSPL)** [DAPM: Retained]  
The $search, $searchMeta, and $vectorSearch stages with hybrid fusion, pre-filtering, and quantization, running on the enterprise's own infrastructure at no additional cost since July 1, 2026, on MongoDB Server 8.3.4 or later. Written Retained on the self-run seam, subject to the SSPL ruling (1A).

**Atlas Vector Search + Search on Search Nodes (Managed Retrieval Surface)** [DAPM: Ceded]  
The same engine on Atlas with dedicated Search Nodes scaled independently of the database (tiered manually), plus vector search in Atlas Stream Processing. MongoDB's managed infrastructure: Ceded.

**Enterprise Advanced Search and Vector Search Add-On (via MongoDB Controllers for Kubernetes)** [DAPM: Ceded]  
The paid self-managed search deployment for Enterprise Advanced, on dedicated search nodes the operator manages. Subscription-gated: Ceded.

**Hosted Voyage Models via the Atlas Embedding and Reranking API (Voyage 4, voyage-code-4, Rerankers)** [DAPM: Ceded]  
An API any application can call for embeddings and reranking on MongoDB-hosted Voyage serving (GA August 13, 2026); the same models through the Voyage API and the three clouds' marketplaces. Embedding carve-out: the vectors are useless without Voyage at query time. Ceded.

**voyage-4-nano (Apache 2.0 Open Weights)** [DAPM: Delegated]  
Voyage's first open-weights embedding model, on Hugging Face under Apache 2.0, in the shared Voyage 4 embedding space. Open weights the enterprise can serve itself: Delegated on the Arctic Embed precedent.

**Gap Analysis:** This is MongoDB's AI product line and it's complete. Vector Search and full-text Search (Lucene-based) are native aggregation stages ($vectorSearch, $search) over the same documents as the application data, with hybrid search (generally available) fusing the two, pre-filtering on document fields, scalar and binary quantization, and dedicated Search Nodes on Atlas for scaling retrieval independently of the database. Voyage AI, acquired in 2025, supplies the models: the Voyage 4 family (January 15, 2026; large, standard, lite, and the open-weights voyage-4-nano under Apache 2.0, all in one shared embedding space), voyage-code-4 for code retrieval, multimodal embeddings, and rerankers, served through the Voyage API, Google Cloud Model Garden, AWS Marketplace, and Azure Managed Applications, and from Atlas through the Embedding and Reranking API (generally available August 13, 2026) for any application, including ones outside MongoDB. Since July 1, 2026 the same Search and Vector Search run self-managed: free in Community Edition under the SSPL on a separate mongot process (MongoDB Server 8.3.4 or later for current Search releases; the 8.2 launch baseline has reached end of life), and as a paid add-on to Enterprise Advanced deployed through MongoDB Controllers for Kubernetes, with no storage caps. Vector search in Atlas Stream Processing extends retrieval to data in motion. The buyer gets governed retrieval next to the system of record, with frontier retrieval models a stage away, and can run the engine themselves.

The architect's concern is the embedding carve-out plus a dependency the self-managed story hides: every vector Voyage produces is useless without Voyage at query time, and the in-database conveniences (Automated Embeddings, native reranking) call MongoDB-hosted Voyage even from a self-managed cluster. voyage-4-nano is the exit for the space, at nano quality. The retrieval pipeline's opinions (index configuration, filters, fusion weights) are the enterprise's to set; the ranking inside is MongoDB's.

Calibration: Elastic reads strong on native hybrid retrieval with sparse, dense, and rerank and a self-run core; Snowflake and Databricks strong on governed managed retrieval; Cohere moderate on frontier retrieval models with a fixed-function managed bundle. MongoDB has Elastic's shape (a retrieval engine the enterprise can run itself) with Cohere's kind of models inside it. Strong.

**Borrowed Judgment:** Split at the engine, total at the space. The retrieval core the enterprise runs itself (Community, mongot) is written Retained on the self-run seam, subject to the SSPL ruling; Search Nodes and the Atlas retrieval surface are MongoDB's managed infrastructure, Ceded; the hosted Voyage models behind the Embedding and Reranking API are model-captive under the carve-out, Ceded; voyage-4-nano under Apache 2.0 is open weights the enterprise can serve itself, Delegated on the Arctic Embed precedent. The runtime tradeoff is MongoDB's engine executing an aggregation pipeline the enterprise wrote, with filters, fusion, and index configuration exposed: vendor decides, visible, overridable, Delegated, the Elastic reading.

### ◑ Layer 1C · Pipelines: Data Movement & Pipelines

*Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering*  
**Status:** Streams and CDC Into and Out of MongoDB; No Lineage, Fixed Destinations

**Decision authority:** Retained (decides: code; visible: true; overridable: true; boundary: vendor)

**Change Streams (Core Engine CDC; Atlas and Self-Managed)** [DAPM: Retained]  
Subscribable insert, update, and delete events on collections, databases, and deployments, in the engine on every path. Engine behavior the enterprise runs: written Retained on the self-run seam, subject to the SSPL ruling (1A).

**MongoDB Kafka Connector (Apache 2.0 Source and Sink)** [DAPM: Retained]  
The Confluent-verified connector streaming MongoDB changes to Kafka and Kafka topics into MongoDB. Apache 2.0 code the enterprise runs: Retained.

**Atlas Stream Processing (Aggregation-Pipeline Processors over Kafka and Change Streams)** [DAPM: Ceded]  
Managed continuous processing with windowing, enrichment, vector search, and Kafka or Atlas sinks across three clouds. The processors are the enterprise's pipelines; the runtime is Atlas-only. Ceded.

**Relational Migrator (Schema Design + Snapshot Migration from SQL Server, MySQL, Oracle, PostgreSQL, TimescaleDB)** [DAPM: Ceded]  
Free, GA tool that maps relational schemas to documents and runs snapshot migration jobs into Atlas or self-managed MongoDB; continuous sync and AI conversion moved to the AMP engagement in 1.15. MongoDB's tool with MongoDB as the only destination: Ceded.

**Data Federation + Online Archive ($out to Object Storage, Federated Queries)** [DAPM: Ceded]  
Query across clusters, archives, and S3, Azure Blob, and Google Cloud Storage; write results out to object storage. Atlas-only: Ceded.

**Gap Analysis:** MongoDB moves data well in the directions it cares about. Change streams, the engine's change data capture (CDC), are a core feature: every insert, update, and delete on a collection is a subscribable event, on Atlas and self-managed alike. Atlas Stream Processing (generally available) runs continuous processors written as MongoDB aggregation pipelines over Apache Kafka topics and change streams, with windowing, $lookup enrichment from Atlas clusters, HTTPS enrichment, $vectorSearch, and sinks to Kafka topics or Atlas collections, on AWS, Azure, and Google Cloud, across providers and regions. The Kafka Connector (Apache 2.0, source and sink) is the Confluent-verified path in both directions. Relational Migrator (free, generally available) designs a MongoDB schema from a relational one and runs snapshot migrations from SQL Server, MySQL, Oracle, PostgreSQL, and TimescaleDB into Atlas or self-managed MongoDB; since release 1.15 (October 2025) continuous sync, large language model (LLM)-assisted query conversion, and entity code generation are offered only inside the Application Modernization Platform engagement, and DB2 and Sybase are public-preview JDBC sources. Data Federation queries across Atlas clusters, Online Archive, S3, Azure Blob, and Google Cloud Storage and writes out with $out. The buyer gets CDC out of MongoDB, stream processing, and snapshot migration into it without a separate integration platform.

The architect's concern is rule 4's coverage test. Sources are Kafka, change streams, HTTPS, and relational snapshots; destinations are MongoDB, Kafka, and object storage. There's no lineage, no catalog of pipelines, no cost-aware movement, and no KV-cache tiering. General in kind for streaming, scoped by destination everywhere else.

Calibration: Snowflake reads strong on Openflow's any-to-any NiFi flows plus streaming plus declarative pipelines; Databricks strong on Lakeflow; Qlik strong on any-to-any CDC; Elastic moderate on ingest fleets with no CDC and no lineage. MongoDB has the CDC Elastic lacks (outbound) and the destination scope Snowflake escapes. Moderate.

**Borrowed Judgment:** Low. Change streams are engine behavior the enterprise runs (written Retained, subject to the SSPL ruling); the Kafka Connector is Apache 2.0; stream processors are aggregation pipelines the enterprise writes and Atlas executes without judgment of its own; Relational Migrator's schema recommendations are MongoDB's, but the mapping the enterprise applies is its own. Code decides, visible, overridable, Retained, the Elastic 1C reading for a vendor whose engine runs the enterprise's transformation logic.

### ◑ Layer 2A · Orchestration: Infrastructure Orchestration

*GPU scheduling, quotas, RBAC, fair-share scheduling, utilization optimization*  
**Status:** Cluster Autoscaling, Operators, and Ops Manager; No GPU Plane

**Decision authority:** Ceded (decides: vendor; visible: true; overridable: false; boundary: vendor)

**Atlas Cluster Auto-Scaling (Reactive Compute Tier, Storage at 90%, Predictive for Eligible M30+) + Search Nodes** [DAPM: Ceded]  
Automatic tier scaling on CPU and memory within customer-set bounds, storage growth on disk utilization, compute-only predictive scaling for eligible clusters, and manually tiered Search Nodes. Atlas-only: Ceded.

**MongoDB Controllers for Kubernetes (Apache 2.0 Operator; Community Mode)** [DAPM: Retained]  
The unified operator deploying Community replica sets with user and role management and Prometheus integration, as YAML custom resources on the enterprise's Kubernetes. Apache 2.0 code the enterprise runs without a subscription: Retained on the open-source seam.

**Ops Manager + Cloud Manager + Enterprise Topologies via the Operator (Enterprise Advanced)** [DAPM: Ceded]  
The management plane for self-managed Enterprise deployments (backup, automation, monitoring) and the operator's Enterprise mode that requires it. Subscription-gated: Ceded.

**Atlas Kubernetes Operator + Atlas Resource Policies** [DAPM: Ceded]  
Atlas projects, clusters, and users managed as Kubernetes custom resources, and organization guardrails in Cedar. Control surfaces over Atlas only: Ceded.

**Gap Analysis:** MongoDB orchestrates its own deployments and nothing else. On Atlas, reactive cluster-tier autoscaling raises or lowers CPU and RAM on dedicated General and Low-CPU clusters (M10 and above) from CPU and memory utilization inside bounds the customer sets, storage autoscaling grows disk when usage reaches 90%, and predictive autoscaling (compute-only, for eligible M30-and-above General and Low-CPU clusters active at least two weeks, excluding NVMe and AWS Gen2 Dedicated tiers) scales ahead of anticipated load; Search Nodes are added and tiered by hand. Atlas Resource Policies bound what developers may provision. Self-managed, MongoDB Controllers for Kubernetes (Apache 2.0 operator code, replacing the separate Enterprise and Community operators) deploys Community replica sets and Enterprise Advanced topologies with Ops Manager or Cloud Manager as the management plane for backup, automation, and monitoring, across single and multiple Kubernetes clusters; the Atlas Kubernetes Operator manages Atlas resources as custom resources. The buyer gets platform-scoped orchestration on both paths.

The architect's concern: none of it schedules anything but MongoDB. No GPU plane, no quotas or fair-share over a shared fleet, no placement across workloads. The autoscaling bounds are configuration the customer sets and Atlas honors within its own placement judgment.

Calibration: Elastic reads moderate with authority Ceded on Elastic Cloud Enterprise, ECK, and Hosted autoscaling; Snowflake and Databricks moderate on managed workload orchestration; Cohere moderate on Model Vault's capacity controls. MongoDB is Elastic's shape. Moderate, Ceded.

**Borrowed Judgment:** Bounded. Atlas autoscaling and Resource Policies are bounds the enterprise sets on MongoDB's placement and scaling judgment: vendor decides, visible, not overridable, Ceded, the Elastic reading. Self-managed, the operator code is Apache 2.0 and Community mode is the enterprise's to run; the Enterprise deployments it manages need Ops Manager or Cloud Manager under Enterprise Advanced.

### ◑ Layer 2B · Runtime: Application Runtime & Execution

*Model serving, agent execution, inference APIs, distributed inference*  
**Status:** Embedding Inference + MCP Tool Surface + Triggers; No LLM Serving, No Agent Runtime

**Decision authority:** Delegated (decides: model; visible: true; overridable: true; boundary: model)

**MongoDB MCP Server (Apache 2.0, Self-Run; Schema, Query, Aggregation, Index, and Atlas Tools; Read-Only Flag)** [DAPM: Retained]  
The community-installed server any MCP client uses to read and write MongoDB and manage Atlas, including local Atlas clusters and Performance Advisor tools, with a read-only mode and per-tool disabling. Open code the enterprise runs, over an open protocol: Retained on the open-source seam.

**Atlas Managed MCP Server (Hosted; OAuth via App Connections or Programmatic MCP Configurations; Native Plugins for Coding Agents)** [DAPM: Ceded]  
A documented subset of the MongoDB MCP tools as a fully hosted Atlas service (GA August 13, 2026): one-click OAuth consent for interactive users, administrator-provisioned configurations with service accounts, roles, IP access lists, and a default-on read-only flag for programmatic agents, and marketplace plugins for Claude Code, Codex, Cursor, Grok Build, and Devin. MongoDB-hosted: Ceded, the Snowflake managed-MCP reading.

**Atlas Triggers + Atlas Functions (Event and Scheduled Execution on MongoDB-Managed App Servers)** [DAPM: Ceded]  
Database and scheduled triggers invoking customer-written JavaScript functions with at-least-once delivery and configurable concurrency, running on MongoDB's app servers. Customer code that runs only inside Atlas: Ceded under the narrowed customer-tools ruling (September 5, 2026).

**Atlas Embedding and Reranking API (Inference Path for Voyage Models)** [DAPM: Ceded]  
Model serving for embeddings and reranking to any application, on MongoDB-hosted Voyage. The retrieval-model inference path, model-captive under the carve-out: Ceded (the models are scored at 1B).

**Gap Analysis:** MongoDB is the store the agents run on, and it ships three thin pieces of the runtime around that. First, inference: the Atlas Embedding and Reranking API (generally available, GA, August 13, 2026) serves the Voyage models to any application, inside or outside MongoDB, which is model serving for the retrieval models and nothing else. Second, the tool surface: the MongoDB MCP Server (Apache 2.0, more than 30,000 installs a week, with a read-only flag and per-tool disabling) lets any Model Context Protocol client inspect schemas, run queries and aggregations, manage indexes, and perform Atlas operations, and the Atlas Managed MCP Server (generally available August 13, 2026) runs a documented subset of those tools as a hosted service inside Atlas, with OAuth consent through App Connections for interactive use, administrator-provisioned MCP configurations with service accounts for programmatic agents, native plugins for Claude Code, Codex, Cursor, Grok Build, and Devin, and actions scoped to the authorizing roles. Third, execution: Atlas Triggers run Atlas Functions (customer JavaScript on MongoDB-managed app servers, 300 seconds and 350 MB per invocation) on database events and schedules, at-least-once, ordered or with up to 10,000 concurrent executions; Triggers survived the 2025 App Services retirement. Agent memory (the LangGraph checkpointer and store, the LangChain partnership) is MongoDB as a database, scored at 1A. The buyer gets their data as a governed tool inside somebody else's agent runtime, with embedding inference on tap.

What MongoDB doesn't ship: no large language model (LLM) serving, no bring-your-own-model endpoint, no agent framework or orchestration loop, no fine-tuning. The runtime is the agent platform the enterprise chose; MongoDB is what it calls.

Calibration: Elastic reads moderate on Agent Builder and brokered LLMs with no serving; Qlik moderate on turnkey agents and automation with no serving; NetApp gap with the runtime being NVIDIA's; Snowflake and Databricks strong on any-model serving plus GA agents. MongoDB has less runtime than Elastic (no agent builder) and more inference than Qlik (a real embedding API). Moderate.

**Borrowed Judgment:** Low and split. The Embedding and Reranking API is model-captive Voyage serving, Ceded under the carve-out (scored at 1B; named here as the inference path). The open-source MCP Server is Apache 2.0 code the enterprise runs, exposing its own database's operations over a standard protocol: Retained. The Managed MCP Server is MongoDB-hosted, Ceded, the Snowflake and Elastic managed-MCP reading. Atlas Functions are customer code that runs only on MongoDB's app servers: Ceded under the narrowed customer-tools ruling (September 5, 2026). The model deciding which tool to call is the external agent's; App Connections' organization-wide read-only mode and each MCP configuration's read-only flag (on by default) are persisted gates the server honors before any write: model decides, visible, overridable, Delegated, at the model boundary.

### ○ Layer 2C · Reasoning: Agentic Infrastructure — The Reasoning Plane

*Policy-driven placement and resource coordination — the Autonomy Layer*  
**Status:** Governed Agent Access to MongoDB (App Connections, MCP Configurations), Not a Reasoning Plane

**Decision authority:** Absent (decides: absent; visible: n/a; overridable: n/a; boundary: vendor)

**Gap Analysis:** MongoDB's answer to the reasoning plane is to be a well-governed tool inside somebody else's, and the governance is better than most data platforms offer. Two access models ship for agents reaching Atlas through the Managed MCP Server (generally available August 13, 2026). User-delegated: Atlas App Connections is an OAuth 2.1 platform through which AI clients act on behalf of Atlas users, disabled by default for existing organizations and for new organizations created by existing users (enabled by default for organizations created by brand-new users at sign-up), with effective permissions the more restrictive of the user's Atlas role and an organization-wide read-only or read-write mode, bounded token lifetimes, and revocation at the organization level immediately and per client within about ten minutes. Programmatic: an Organization or Project Owner provisions an MCP configuration for an automated agent, Atlas creates a pair of service accounts for it (one to reach the server, one recorded in audit events), and each configuration carries its own Atlas roles, an optional IP access list, and a read-only flag preselected on; the agent acts as the configuration, not as a user. Audit events that are generated carry the authorizing user and client, or the service account, but Atlas doesn't record individual tool calls, and read-only Administration API calls aren't logged. Applying the test: Intelligence-2C asks which agent may act, under whose identity, within what policy, across the estate. MongoDB answers it for one resource, MongoDB, with a real non-user principal on the programmatic path and documented gaps (revocation doesn't remove artifacts a client created; owners can't revoke a single user-to-client grant). There's no agent registry, no gateway over calls to other systems, no cross-agent orchestration, no observability of agents, and no placement across model, cost, or compliance tiers.

Calibration: Qlik reads gap with authority Absent on the same posture, a governed MCP tool inside the enterprise's chosen agentic infrastructure; Anthropic and Elastic hold runtime permissions and catalogs below or at the moderate bar; Snowflake reads moderate on first-class agent identity plus a registry leg and observability; Databricks moderate on on-behalf-of auth plus a gateway. MongoDB has Snowflake's kind of agent principal for one resource and none of the other legs. Gap, Absent, written pending Keith's ruling on whether a single-resource agent identity is a 2C leg.

**Borrowed Judgment:** None to borrow, and that's the finding: App Connections and MCP configurations govern access to MongoDB, a property of the 2B tool surface. To the extent a reasoning plane exists in a MongoDB estate, the enterprise built it around MongoDB. Absent: nothing offered at the layer's function, nothing inherited.

### ◑ Layer 3 (+1) · Applications: AI Application Layer — The Value Plane

*AI-powered business capabilities — business logic, workflow automation*  
**Status:** Developer-Tooling and Analytics Value Plane, MongoDB-Bound; No Business Applications

**Decision authority:** Ceded (decides: vendor; visible: true; overridable: false; boundary: vendor)

**Intelligent Assistant in Compass and Atlas Data Explorer (GA January 15, 2026)** [DAPM: Ceded]  
Conversational MongoDB guidance and natural-language querying through read-only tools that require the user's approval before execution, disableable per project. MongoDB's assistant: Ceded.

**Atlas Charts (Dashboards, Embedded Analytics, Natural Language Charts)** [DAPM: Ceded]  
Dashboards and charts over Atlas data with sharing, iframe and SDK embedding, and prompt-built charts. Atlas-only visualization: Ceded.

**Gap Analysis:** MongoDB's applications are for the people who run MongoDB and the data inside it. The intelligent assistant in Compass and Atlas Data Explorer (generally available January 15, 2026) answers MongoDB-specific questions in natural language and queries the database through read-only tools that require the user's approval before each execution, with tool calling disableable at the project level. Atlas Charts is dashboards and embedded analytics over MongoDB data, shareable, embeddable by iframe or SDK, with Natural Language Charts building charts from prompts. Relational Migrator's large language model (LLM)-assisted query conversion and code generation moved into the Application Modernization Platform (AMP) engagement in release 1.15 (October 2025), leaving the tool a deterministic schema and snapshot migrator scored at 1C, and AMP itself, which wraps analysis, transformation, and validation agents around MongoDB's modernization methodology, is sold as a services engagement with no general-availability badge. The buyer gets a narrow, MongoDB-bound analytics and developer value plane: real, generally available (GA), and thin once the AI conversion is subtracted.

Applying the test: the layer asks for AI-powered business capabilities, and what ships GA with AI inside is an administration assistant and prompt-built charts; the analytics surface is a value plane a business user touches, but only over MongoDB data.

Calibration: Elastic and Qlik read strong on first-party security, observability, and analytics applications; Snowflake and Databricks strong on agents, observability, apps, and marketplaces; Nutanix moderate on platform-enabled applications; NetApp gap as a foundation beneath others' apps. MongoDB sits between Nutanix and NetApp: shipped first-party tooling and analytics, no application that runs a business process. Moderate, written pending Keith's read on whether the surface that remains after the AMP subtraction still clears the bar.

**Borrowed Judgment:** Low at the tooling, and it doesn't compound the way a workspace does: the assistant's answers are advice; Charts dashboards rebuild elsewhere. What's Ceded is the tooling itself and its opinions about what to chart and how to query. Vendor decides, visible, not overridable, Ceded, the first-party tooling reading; the assistant's per-execution approval on read-only query tools is a 2B-shaped gate on a tool, named here, not an override of the application's opinions.

---
*Layer2C · AI Infrastructure Decision Intelligence · The CTO Advisor LLC (DBA The Advisor Bench) · thectoadvisor.com*