Confluent is the data streaming platform, and since March 17, 2026 it's an IBM company that IBM says will keep operating as a distinct brand. The map reads it as strong at one layer and moderate at four. Layer 1C is the heartland: Apache Kafka, one hundred-plus fully managed connectors, Apache Flink as SQL, Table API, user-defined functions and process table functions, Kafka Streams, Cluster Linking, and Tableflow, on a fully managed cloud, a self-managed platform, a private cloud package, and WarpStream's bring-your-own-cloud diskless Kafka. Layer 1A is moderate: the durable event log with tiered storage, Tableflow materializing topics as Iceberg and Delta Lake tables in the enterprise's own buckets, and Stream Governance (Schema Registry, data contracts, catalog, lineage, a data portal) govern data in motion, not a general estate. Layer 1B is moderate on Flink's federated key, text, and vector search against the enterprise's own stores and on the Real-Time Context Engine serving topic state to agents over the Model Context Protocol. Layer 2A is moderate on elastic clusters, Flink compute pools with Autopilot, and Kubernetes operators for the platform's own components. Layer 2B is moderate: Streaming Agents (generally available May 19, 2026) run event-driven, tool-calling agents on Flink against the enterprise's own model accounts, but Confluent serves no models of its own in production (managed models are Early Access) and the agent surface is four months past general availability with reflection, Agent2Agent, and tool invocation still in preview. Layers 0, 2C, and 3 are gaps: no substrate, no agent-governance plane beyond the runtime's own audit and replay, and no application (the AI Assistant and Copilot are preview and Early Access).
The capture is coupled at the log and decoupled everywhere else. Kafka's protocol is a genuine multi-vendor standard (Apache Kafka, Redpanda, WarpStream, Amazon MSK, and Azure Event Hubs all speak it), Flink SQL and the Flink APIs are Apache Flink's, Tableflow writes open table formats to the enterprise's storage behind an Iceberg REST catalog, and the Schema Registry interface has second implementers. That is why Confluent Cloud's Kafka and Flink read Delegated and the self-run Apache components, the enterprise's own connector plugins, user-defined functions, and Ansible playbooks read Retained. What is Confluent's and stays Confluent's: the fully managed connector implementations, Cluster Linking, Confluent Server's commercial features, Confluent for Kubernetes, the Private Cloud Gateway, the Confluent-specific Flink extensions that carry the AI story (CREATE MODEL, CREATE AGENT, CREATE TOOL, the AI_ and ML_ functions, external table search), the Real-Time Context Engine, Stream Governance's catalog, lineage, and data-contract rules, and the provider-native model bindings (Bedrock, SageMaker, Vertex) that read Ceded to their providers. The Confluent Community License components (Schema Registry, ksqlDB, REST Proxy) sit on the same seam as MongoDB's SSPL and are written Retained pending that ruling.
The buyer's trade: the operational estate's event log, with pipelines and now agents that run where the events are, on interfaces the enterprise can take elsewhere, in exchange for a governance layer and an AI layer that exist only as Confluent's extensions to open engines. The decision-authority readings follow: code / Retained at 1C, where Flink and Kafka Streams execute what the enterprise wrote; vendor / Delegated at 1A and 1B; vendor / Ceded at 2A on Confluent Cloud's autoscaling bounds; and model / Ceded at 2B, because a Streaming Agent's tool calls execute inside the Flink loop with no documented deterministic gate before the effect. What would move cells: managed models reaching general availability (2B), a first-class agent identity and registry (2C), Tableflow on Google Cloud and Confluent Platform (1A), and any of the preview assistants reaching general availability (Layer 3).
Layer-by-layer status: Layer 0 (Not Confluent's Layer (By Design); Confluent Cloud on the Hyperscalers, WarpStream in Your Account, Platform and Private Cloud on Your Kubernetes), Layer 1A (The Event Log as a Governed Foundation: Tiered Topics, Tableflow to Iceberg and Delta in Your Buckets, Schema Registry With Data Contracts, Stream Catalog and Lineage), Layer 1B (Federated Vector, Text, and Key Search From Flink Into the Enterprise's Own Stores + Real-Time Context Engine Serving Topic State Over MCP; No Confluent-Owned Vector Index), Layer 1C (The Heartland: Kafka, 100+ Managed Connectors, Flink SQL and Table API, Kafka Streams, Cluster Linking, and Tableflow on Confluent Cloud; Kafka, Connect, and Flink on Platform, Private Cloud, and WarpStream), Layer 2A (Elastic Clusters and Flink Compute Pools With Autopilot on Confluent Cloud; Confluent for Kubernetes, Confluent Manager for Flink, and the Private Cloud Gateway on Yours; No GPU Plane), Layer 2B (Streaming Agents on Flink (GA May 2026) Against the Enterprise's Own Model Accounts; ML Functions; No Model Serving in Production (Managed Models Early Access)), Layer 2C (Agent Governance Lives Inside the Streaming Agent Runtime (RBAC, Audit, Replay); Kafka Is the Coordination Bus, Not a Governance Plane; A2A in Open Preview), Layer 3 (+1) (No Application; the AI Assistant, Connector Troubleshooting, and Copilot Are Preview and Early Access).
Assessment framework: 4+1 Layer AI Infrastructure Model. Scoring model: Decision Authority Placement Model (DAPM) — Retained, Delegated, or Ceded. Published by The CTO Advisor LLC (DBA The Advisor Bench). Author: Keith Townsend. Date assessed: September 10, 2026. Version: v1.0 - 4+1 v2: Authority Split.
Confluent is the data streaming platform, and since March 17, 2026 it's an IBM company that IBM says will keep operating as a distinct brand. The map reads it as strong at one layer and moderate at four. Layer 1C is the heartland: Apache Kafka, one hundred-plus fully managed connectors, Apache Flink as SQL, Table API, user-defined functions and process table functions, Kafka Streams, Cluster Linking, and Tableflow, on a fully managed cloud, a self-managed platform, a private cloud package, and WarpStream's bring-your-own-cloud diskless Kafka. Layer 1A is moderate: the durable event log with tiered storage, Tableflow materializing topics as Iceberg and Delta Lake tables in the enterprise's own buckets, and Stream Governance (Schema Registry, data contracts, catalog, lineage, a data portal) govern data in motion, not a general estate. Layer 1B is moderate on Flink's federated key, text, and vector search against the enterprise's own stores and on the Real-Time Context Engine serving topic state to agents over the Model Context Protocol. Layer 2A is moderate on elastic clusters, Flink compute pools with Autopilot, and Kubernetes operators for the platform's own components. Layer 2B is moderate: Streaming Agents (generally available May 19, 2026) run event-driven, tool-calling agents on Flink against the enterprise's own model accounts, but Confluent serves no models of its own in production (managed models are Early Access) and the agent surface is four months past general availability with reflection, Agent2Agent, and tool invocation still in preview. Layers 0, 2C, and 3 are gaps: no substrate, no agent-governance plane beyond the runtime's own audit and replay, and no application (the AI Assistant and Copilot are preview and Early Access).
The capture is coupled at the log and decoupled everywhere else. Kafka's protocol is a genuine multi-vendor standard (Apache Kafka, Redpanda, WarpStream, Amazon MSK, and Azure Event Hubs all speak it), Flink SQL and the Flink APIs are Apache Flink's, Tableflow writes open table formats to the enterprise's storage behind an Iceberg REST catalog, and the Schema Registry interface has second implementers. That is why Confluent Cloud's Kafka and Flink read Delegated and the self-run Apache components, the enterprise's own connector plugins, user-defined functions, and Ansible playbooks read Retained. What is Confluent's and stays Confluent's: the fully managed connector implementations, Cluster Linking, Confluent Server's commercial features, Confluent for Kubernetes, the Private Cloud Gateway, the Confluent-specific Flink extensions that carry the AI story (CREATE MODEL, CREATE AGENT, CREATE TOOL, the AI_ and ML_ functions, external table search), the Real-Time Context Engine, Stream Governance's catalog, lineage, and data-contract rules, and the provider-native model bindings (Bedrock, SageMaker, Vertex) that read Ceded to their providers. The Confluent Community License components (Schema Registry, ksqlDB, REST Proxy) sit on the same seam as MongoDB's SSPL and are written Retained pending that ruling.
The buyer's trade: the operational estate's event log, with pipelines and now agents that run where the events are, on interfaces the enterprise can take elsewhere, in exchange for a governance layer and an AI layer that exist only as Confluent's extensions to open engines. The decision-authority readings follow: code / Retained at 1C, where Flink and Kafka Streams execute what the enterprise wrote; vendor / Delegated at 1A and 1B; vendor / Ceded at 2A on Confluent Cloud's autoscaling bounds; and model / Ceded at 2B, because a Streaming Agent's tool calls execute inside the Flink loop with no documented deterministic gate before the effect. What would move cells: managed models reaching general availability (2B), a first-class agent identity and registry (2C), Tableflow on Google Cloud and Confluent Platform (1A), and any of the preview assistants reaching general availability (Layer 3).
Raw compute, networking, and acceleration fabric
Managed AI models (Early Access) run on graphics processing units (GPUs) Confluent hosts and the customer never sees; the time-series models in Early Access are served the same way. Nothing in the generally available product asks the enterprise for an accelerator.
Confluent sells software and a service, on four shapes, and none is a substrate the enterprise administers as its own. Confluent Cloud runs on AWS, Azure, and Google Cloud in Confluent's accounts (Basic, Standard, Enterprise, Dedicated, and Freight clusters; Freight is diskless on object storage in select AWS regions), with private networking into the enterprise's virtual networks (on AWS, Private Network Interface attaches elastic network interfaces the enterprise owns and controls in its own virtual private cloud (VPC): connectivity the enterprise administers, not a substrate). WarpStream is bring-your-own-cloud (BYOC): stateless agents run in the enterprise's own account against the enterprise's own object storage, with only the control plane at Confluent. Confluent Platform installs on the enterprise's own Linux hosts, virtual machines, or Kubernetes (Confluent for Kubernetes, Ansible, ZIP, systemd, Docker, AWS Outposts), and Confluent Private Cloud (October 2025) is the same platform packaged for a Kubernetes the enterprise already runs. The buyer gets Kafka on whatever it already has. The architect's concern is the usual one: on Confluent Cloud the compute decisions are Confluent's and invisible below the cluster type, cloud, and region (Dedicated clusters expose a Confluent Unit for Kafka (CKU) count; Basic, Standard, Enterprise, and Freight scale in elastic CKUs (eCKUs) inside Confluent's limits or a ceiling the enterprise sets); on the other shapes they are the enterprise's and never Confluent's. Calibration: Databricks, Snowflake, Elastic, MongoDB, and Redis read gap on software or a service that runs on someone else's substrate. Gap. The authority cohort is narrower: Elastic, MongoDB, and Redis read Absent under rule 7 on the same mixed hosted-plus-self-managed shape, and that's the reading here; Databricks carries Ceded authority on a hosted-only shape.
None to Confluent as a substrate. On Confluent Cloud the enterprise picks a cluster type, a cloud, and a region (and a CKU count on Dedicated) and inherits the hyperscaler's substrate through Confluent's account; on WarpStream, Platform, and Private Cloud the substrate is the enterprise's own choice. Absent.
Confluent Cloud for Government carries FedRAMP Moderate authorization (March 2026), a procurement fact. Public evidence that moves the cell: Confluent selling or operating compute, networking, acceleration, or storage substrate the enterprise administers as its own, which nothing in the documentation describes.
Durable, governed data foundation — the Governance Catalog that Layer 2C queries
The durable log the enterprise operates on its own hosts or Kubernetes. Open source the enterprise runs, with the Kafka protocol as its interface: Retained.
Proprietary engines operated by Confluent (or, for WarpStream, Confluent's control plane with the enterprise's agents and object storage) behind a multi-vendor standard interface. Topics, partitions, and client code lift to any Kafka-protocol implementation: Delegated.
Confluent's proprietary broker features on the enterprise's own hardware. Self-deployable isn't Retained; the placement and tiering opinions are Confluent's: Ceded.
Open table formats in the enterprise's own storage, so the tables outlive Confluent. The Iceberg path is multi-engine through the REST catalog standard and synced catalogs; the Delta path is documented as available only through the Unity Catalog integration. Delegated for the tables, the Qlik reading (open Iceberg Delegated, the optimizer Ceded): the schematization, compaction, and catalog-publishing service that writes them is Confluent's and is the Ceded Tableflow chip at Layer 1C. Confluent Managed Storage, whose files are readable only with Confluent-vended credentials, is the Ceded variant.
The managed registry behind an interface Redpanda and Apicurio also implement, so schemas, subjects, and compatibility settings port. Delegated at the registry interface.
Rules, metadata, and field-encryption bindings in Confluent's own format, gated to the Advanced package on Confluent Cloud and to Confluent Enterprise on Platform, with no second implementer running them. Ceded, the path-split reading: the registry API ports, the contract on top of it doesn't.
Source-available code the enterprise runs itself; the license forbids only a competing hosted service. Retained on possess-and-operate (ruled September 15, 2026: if it's movable today, it's Retained; MongoDB's SSPL core stands on the same line); Ceded if source-available reads as Elastic License 2.0 did.
The catalog of streams, the lineage map, and the discovery portal. Confluent metadata with no second implementer: Ceded.
Brokers, tiered storage, Tableflow materialization, and Schema Registry run on CPUs.
Confluent's data foundation is the log. Topics are durable, replicated, and tiered to object storage; on Confluent Cloud they are retained as long as the enterprise pays, on Confluent Platform Tiered Storage offloads history to the enterprise's own buckets. Tableflow (Iceberg generally available on AWS since March 2025, Delta Lake since October 2025, Azure since January 2026) materializes topics as Apache Iceberg or Delta Lake tables with schematization from Schema Registry, change data capture (CDC) materialization, upsert tables, compaction, and a built-in Iceberg REST catalog, into the enterprise's own S3 or Azure storage (Bring Your Own Storage) or Confluent Managed Storage, and syncs table metadata to AWS Glue, Databricks Unity Catalog, and Snowflake's Polaris-based Open Catalog; any engine that reads Iceberg reads the result through the built-in REST catalog or a synced catalog; the Delta tables are reachable only through the Unity Catalog integration. Stream Governance is the governance layer: Schema Registry with Avro, Protobuf, and JSON Schema, compatibility modes, broker-side schema validation, and Schema Linking; data contracts with data quality rules, migration rules in Common Expression Language (CEL) or JSONata, and metadata (Advanced package); Stream Catalog with tags, business metadata, REST and GraphQL application programming interfaces (APIs); Stream Lineage as an interactive map of topics, connectors, and Flink statements (ten minutes in Essentials, seven days in Advanced); and the Data Portal for self-service discovery and access requests. Security is role-based access control (RBAC) down to topics, consumer groups, and schema subjects, access control lists, audit logs, bring-your-own-key encryption, and client-side field-level encryption. The buyer gets a governed, durable record of what happened, and a way to make it a lakehouse table without a pipeline. The architect's concern is scope. This governs data in motion and the tables Tableflow writes; it isn't a catalog of the enterprise's estate, it enforces at the topic and schema, not the row (client-side field-level encryption is the closest thing to column policy), Tableflow isn't available on Google Cloud, on Confluent Platform, or on privately networked clusters with Confluent's storage, and the catalog, lineage, and data-contract rules are Confluent objects. Calibration: Databricks, Snowflake, and Cloudera read strong on lakehouses with governance authority that owns the tables' grants; Qlik reads moderate on an open lakehouse the enterprise stores plus a captive trust layer; Redis moderate on an in-memory system of record with a feature store; Elastic moderate on a search estate. Confluent is Qlik's shape from the other direction: an operational record in open formats plus a governance layer scoped to streams. Moderate.
Split at the protocol, captive at the catalog. Apache Kafka topics the enterprise runs itself are its own: Retained. Confluent Cloud's Kora engine and WarpStream's agents are proprietary implementations behind the Kafka protocol, which Apache Kafka, Redpanda, Amazon MSK, and Azure Event Hubs also implement: Delegated. Tableflow writes Iceberg and Delta to the enterprise's buckets behind the Iceberg REST catalog standard: Delegated for the tables (the Qlik split: open tables Delegated, the service that materializes and maintains them Ceded, scored at Layer 1C), with Confluent Managed Storage the Ceded variant (its files are readable only with credentials the Confluent catalog vends). Confluent Server's commercial features (Tiered Storage, Self-Balancing Clusters) and the Stream Governance surfaces (catalog, lineage, data-contract rules, Data Portal) are Confluent's: Ceded. The Schema Registry API is implemented by Redpanda and Apicurio, so schemas and compatibility settings port, but the self-run registry is Confluent Community License code and is written Retained pending the source-available ruling. The runtime call at this layer is the broker enforcing schemas and compatibility modes the enterprise set per subject and per topic, with override per object: vendor decides, visible, overridable, Delegated, the Elastic reading.
Ruled September 15, 2026: the self-run Confluent Community License components (Schema Registry, ksqlDB, REST Proxy, community connectors) read Retained on the possess-and-operate reading (if it's movable today, it's Retained); the license bars only competing software-as-a-service offerings and Confluent's FAQ calls it source-available, not open source; MongoDB's SSPL core stands on the same line. The ChatGPT pass had voted Ceded on the ELv2 precedent. Tableflow limitations from the documentation: not on Google Cloud, not on Confluent Platform, Confluent Managed Storage not on privately networked clusters, Delta Lake only with Bring Your Own Storage, schemaless topics unsupported; client-side field-level encryption with Tableflow and data time-to-live are Limited Availability and unscored. Public evidence that moves the cell: row- or column-level policy on topic data enforced by the platform, or Tableflow on every cloud and on Confluent Platform.
Low-latency retrieval for RAG — vector/hybrid search, context windows
Read-only lookup joins from a stream into the enterprise's own stores. The stores are the enterprise's; the CREATE TABLE connector and search functions are Confluent's Flink extensions with no second implementer: Ceded.
A Confluent-managed serving layer over the enterprise's topics, exposed through MCP. The interface is standard, the tables and tool descriptions are Confluent's: Ceded, the vendor-hosted MCP reading.
Vectors made by a third party's model on the enterprise's own keys. Model-captive under the carve-out: Ceded to the owner through Confluent's paper.
Embeddings come from the enterprise's model provider through AI_EMBEDDING; the managed embedding model (bge-large on Confluent-hosted GPUs) is Early Access and unscored.
Confluent retrieves from other people's indexes and serves its own topics as context. Confluent Cloud for Apache Flink's external tables (generally available November 20, 2025) run a per-row lookup join from a stream into an external system: key search against Postgres, MySQL, SQL Server, Oracle, Couchbase, MongoDB, or any REST endpoint; full-text search against Elasticsearch, MongoDB, or Couchbase; vector search (VECTOR_SEARCH_AGG) against Amazon S3 Vectors, Azure Cosmos DB, Couchbase, Elasticsearch, MongoDB, or Pinecone, typically with AI_EMBEDDING embedding the probe column inline through the enterprise's own model account, over AWS and Azure Private Link. The Real-Time Context Engine (Early Access October 2025, generally available May 19, 2026) is the other half: enable it on a schematized topic and Confluent materializes the topic into a low-latency serving table (append mode for events, upsert mode for the latest state per key) that agents query through Model Context Protocol (MCP) tools with key lookups, filters, ranges, compound predicates, projections, and ordering, under Confluent Cloud role-based access control (RBAC) and audit logging, on Basic, Standard, Enterprise, and Dedicated clusters on AWS; lightning queries (Early Access, August 2026) open the same table to plain REST reads. The buyer gets retrieval-augmented generation (RAG) as a streaming pipeline stage against the stores it already runs, and live topic state as agent context without standing up a second operational database for it. The architect's concern is that there's no retrieval engine here. The vector index is the enterprise's own store, Flink's search functions are Confluent-specific SQL, the Context Engine is a Confluent serving layer (AWS only, key and filter queries, no vector search), and every vector belongs to whichever model made it. Calibration: Elastic, MongoDB, and Snowflake read strong on native hybrid engines; Cloudflare and Cohere moderate on an index or models without the other; Redis moderate on an open engine with preview models; Anthropic moderate on federated search without a retrieval estate. Confluent is federated search plus a state-serving layer, the Anthropic and Cloudflare shape. Moderate.
Low at the store, captive at the function. The stores are the enterprise's own (Elasticsearch, MongoDB, Pinecone, Cosmos DB, S3 Vectors, Postgres) and are scored on their owners' rows; the Flink search functions and external table definitions that reach them are Confluent's SQL: Ceded. The Real-Time Context Engine's tables and MCP tools are Confluent's managed surface over the enterprise's topics: Ceded. Embeddings through AI_EMBEDDING belong to the model owner under the carve-out: Ceded. The runtime call is Flink executing a search the enterprise wrote (limit, function, filters) against a store the enterprise chose, and, on the generally available path, the Context Engine answering the queryData call an agent composed through MCP (direct queries without an agent are Early Access and unscored), with per-statement override: vendor decides, visible, overridable, Delegated, the Elastic reading, anchored on the Flink search statements.
Unscored on their badges: managed embedding models (Early Access, AWS us-east-1, us-east-2, us-west-2), lightning queries (Early Access), AI_TOOL_INVOKE (preview). Inference flagged: the Context Engine's region list changes; the documentation names AWS only. Public evidence that moves the cell: a Confluent-owned vector index, or vector search in the Context Engine.
Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering
The open engines and the enterprise's topologies, statements, and connector configurations on them. Retained on the open-source seam; Confluent Manager for Apache Flink and Confluent for Kubernetes, the operators around them, are Ceded chips at Layer 2A. Custom connectors are Kafka Connect plugins the enterprise builds from scratch, modifies from open source, or takes from a third party and uploads; Confluent supports only the Connect infrastructure under them. Plugin logic on Apache Kafka Connect's multi-vendor interface runs on any Connect cluster: Retained, the customer-tools reading.
Managed Flink and Kafka behind Flink SQL, the Flink Table API, and the Kafka protocol; standard statements and topologies lift to any Flink and any Kafka. Delegated, the Databricks Spark reading. Confluent-only statements (models, agents, tools, search) are Ceded at their own layers.
Confluent-built and Confluent-operated connector implementations with their own configuration surface and support lifecycle. Curated connectors: Ceded, the Snowflake Openflow Connectors and Databricks Lakeflow Connect reading.
Confluent's replication protocol between Confluent clusters (Confluent Cloud and Confluent Platform destinations; Apache Kafka as a source for migration), with no second implementer. Ceded.
The pipeline function of Tableflow, scored here for what it moves; the tables it writes are the Delegated chip at Layer 1A. The materialization service is Confluent's: Ceded. WarpStream Tableflow is the same shape: its documentation says the tables are 'fully managed by WarpStream' and no other system may write, compact, or maintain them. Ceded.
A proprietary Kafka-protocol implementation whose data plane and data live in the enterprise's account with Confluent's control plane. Delegated behind the protocol; Orbit and the WarpStream console are Confluent's, and WarpStream Tableflow is the Ceded chip above.
Lineage is in this layer's definition; the map and the hybrid console are Confluent's: Ceded.
Brokers, connectors, and Flink run on CPUs. The ML functions that call models are scored at Layer 2B.
This is the layer Confluent was founded on, and it now spans the whole path from source to lakehouse. Movement: one hundred-plus fully managed connectors on Confluent Cloud (change data capture (CDC) from Debezium sources including Oracle XStream, Postgres, MySQL, SQL Server, Spanner; databases, object storage, warehouses, SaaS applications, message queues, observability), custom connectors the enterprise uploads and runs on Confluent's infrastructure, self-managed Kafka Connect on Confluent Platform, and Cluster Linking mirroring topics across clusters, regions, clouds, and private networks. Transformation: Confluent Cloud for Apache Flink with Flink SQL, the Table API for Java (generally available July 2026; Python in Open Preview), user-defined functions with external connectivity, process table functions (generally available June 2026), materialized tables, snapshot queries, changelog conversion, a dbt adapter, Autopilot scaling, and event logging; Kafka Streams; ksqlDB; and on Confluent Platform, Flink SQL generally available since 8.2 under Confluent Manager for Apache Flink across multiple Kubernetes clusters. Destination: any sink connector, Cluster Linking into Confluent Cloud or Confluent Platform clusters (Apache Kafka clusters are supported as sources for migration, not as destinations), and Tableflow into Iceberg and Delta on Confluent Cloud (AWS and Azure; WarpStream has its own Tableflow). Lineage: Stream Lineage across topics, connectors, and Flink statements. Unified Stream Manager governs and monitors self-managed and cloud clusters from one console. The buyer gets the operational data path itself, with the transform running where the events are. The architect's concern is which parts are Apache and which are Confluent. Kafka, Kafka Connect, Kafka Streams, and Flink are Apache projects and the enterprise's statements and topologies are standard; the fully managed connectors, Cluster Linking, the Confluent Cloud Flink extensions, ksqlDB, and Stream Lineage are Confluent's, and Freight clusters don't support transactions or idempotent producers. Calibration: Cloudera reads strong on NiFi, Kafka, Flink, and Spark from any source to any destination; Qlik strong on CDC plus Talend; Databricks strong on Lakeflow and Spark; Snowflake strong on Openflow and streaming ingest. Confluent is the platform three of those peers embed for streaming, general under rule 4 (arbitrary code, insertable stages, any destination), and the frontier for data in motion under rule 6. Strong.
Low at the engines, captive at Confluent's edges. Apache Kafka, Kafka Connect, Kafka Streams, and Apache Flink the enterprise runs are its own, and so are the connector plugins it writes against Kafka Connect's interface and uploads to Confluent Cloud: Retained. Confluent Cloud's managed Kafka and Flink are operated implementations behind the Kafka protocol and Flink SQL: Delegated. The fully managed connectors, Cluster Linking, Tableflow's pipeline role (Confluent's and WarpStream's), ksqlDB, Stream Lineage, and Confluent's Flink-only statements are Confluent's: Ceded. The runtime call is Flink and Kafka Streams executing statements and topologies the enterprise wrote, with the engine exercising no judgment of its own (Autopilot's scaling is a Layer 2A call): code decides, visible, overridable, Retained, the Elastic, MongoDB, Cloudflare, and Redis reading; the curated connectors' authority reading is vendor / Delegated on the Snowflake and Cloudera rows (their portability badge is Ceded either way), and this row follows the engine because the engine is the layer.
Ruled September 15, 2026 (authority): code / Retained stands; the 1C authority reading follows the half that carries the grade (Confluent's is the engine executing enterprise-declared jobs, the override paragraph's code / Retained case; Cloudera's and Snowflake's are curated connector catalogs, vendor / Delegated). Written code / Retained on the engine half; the ChatGPT pass votes vendor / Delegated on the Cloudera and Snowflake readings, and the September 5 sheet's 1C authority split decides this cell too. Freight clusters: the documentation lists idempotent producers and transactions as unsupported. Confluent Platform's Health+ is deprecated (retirement end of 2026) in favor of Unified Stream Manager. Public evidence that moves the cell: nothing upward from strong.
GPU scheduling, quotas, RBAC, fair-share scheduling, utilization optimization
Confluent's control plane sizing Confluent's service inside the enterprise's bounds. Ceded.
Operators for Confluent components only, licensed under the Confluent Enterprise License with Confluent Platform. Ceded; the Kubernetes underneath is the enterprise's own.
Open-source playbooks the enterprise runs and modifies to install Confluent Platform on hosts, listed under the Apache 2.0 License in Confluent's own license table. Open source the enterprise operates: Retained.
The substrate the enterprise built and operates. Retained, the Cloudera customer-run OpenShift reading.
Proprietary agent containers the enterprise places and scales with standard Kubernetes controls, under WarpStream's control plane. Delegated, matching the row's WarpStream reading at Layers 1A and 1C.
Confluent's routing layer between clients and clusters and its replication mode. Ceded.
Confluent Cloud's console over the enterprise's self-managed clusters through an agent. Registration requires Confluent Platform 7.9.6 or later (7.9 line) or 8.1 and later and private networking (AWS PrivateLink or Azure Private Link); public networking and Google Cloud are unsupported. Ceded.
Confluent schedules brokers, connectors, and Flink statements. The only GPUs in the product are the ones behind Early Access managed models, invisible to the customer.
Confluent orchestrates its own platform, on two shapes. On Confluent Cloud the orchestration is elastic and Confluent's: Standard and Enterprise clusters scale automatically in elastic Confluent Units for Kafka (eCKUs; up to 32 on Enterprise, with a max-eCKU ceiling the enterprise sets that bounds capacity and billing, though the documentation says requests, client connections, and connection attempts under a lowered ceiling aren't strictly enforced), Dedicated clusters scale in CKUs on request (up to 252 on AWS), Freight clusters are diskless, connectors scale elastically with no infrastructure, and Flink statements run in compute pools where Autopilot sizes each statement in Confluent Flink Units (CFUs) inside the pool's maximum (a Baseline CFU floor is Limited Availability). Role-based access control (RBAC) scopes every resource, service quotas bound the organization, cost allocation tags spend, and release priority sequences upgrades across Dedicated clusters. On the enterprise's Kubernetes, Confluent for Kubernetes (CFK 3.3.0, June 2026, Kubernetes 1.28 to 1.36 and OpenShift 4.15 to 4.22) deploys brokers, Connect, ksqlDB, Schema Registry, Control Center, and REST Proxy as custom resources with rolling upgrades, scaling, rack awareness, and pod and node affinity and tolerations; Confluent Manager for Apache Flink runs a fleet of Flink applications across several Kubernetes clusters with shared compute pools and savepoint management; Ansible playbooks do the same on hosts; Confluent Private Cloud adds a Kafka-protocol gateway that routes, fences, and re-authenticates clients centrally and Intelligent Replication that switches between push and pull; Unified Stream Manager registers and monitors the self-managed clusters it supports (Confluent Platform 7.9.6 or later in the 7.9 line, or 8.1 and later, over AWS PrivateLink or Azure Private Link; no public networking, no Google Cloud) from Confluent Cloud. WarpStream's stateless agents deploy on the enterprise's Kubernetes through official Helm charts with horizontal pod autoscaling and zone-aware scaling, or on Amazon Elastic Container Service (ECS). The buyer gets Kafka and Flink that size themselves, and a declarative control plane for the self-managed estate. The architect's concern is that this is orchestration of Confluent's components only, with no general scheduler and no GPU. CFK manages Confluent resources, not third-party workloads; Autopilot's decisions are visible in event logs but not reversible per statement beyond the pool maximum; Private Cloud's bin packing and fleet manager are roadmap. Calibration: Cloudera reads moderate on a platform-scoped Kubernetes with quota pools; Databricks and Snowflake moderate on managed compute with bounds and no customer-visible scheduler; Redis moderate on a cluster manager and operator. Confluent is the Redis shape at larger scale. Moderate.
Split at the cluster. A Kubernetes the enterprise runs for Confluent Platform is its own, and so are the Apache 2.0 Ansible playbooks it runs and modifies: Retained. WarpStream's agents on that Kubernetes, placed and scaled with standard Kubernetes controls under WarpStream's control plane: Delegated. Everything Confluent layers on it or runs for it (CFK, CMF, the Private Cloud Gateway, Confluent Cloud's cluster and pool lifecycle, Autopilot, Unified Stream Manager) is Confluent's: Ceded. The runtime call on the primary path, Confluent Cloud, is Confluent's autoscaler sizing clusters and statements inside maximums the enterprise set; maximums are bounds, not overrides, so vendor decides, visible, not overridable, Ceded, the Snowflake, Databricks, and Cloudera reading. CFK's affinity and tolerations are documented pins on the self-managed path and would read Delegated there; the primary path governs the cell.
Cross-row: the same primary-path question as Dataiku's 2A, read the other way because Confluent's dominant shape is its own cloud; both belong to the 2A column re-read under the override rule (September 5 sheet). Baseline CFU (Limited Availability), Private Cloud bin packing and fleet manager (roadmap, October 2025 post), and Confluent Copilot's operational actions (Early Access) are unscored. Public evidence that moves the cell: nothing here grades GPU scheduling; a per-statement scaling override would move the authority reading.
Model serving, agent execution, inference APIs, distributed inference
The agent harness and the AI verbs, all Confluent-only SQL on Confluent Cloud for Apache Flink. Ceded.
The enterprise's keys against multi-vendor inference interfaces, called per row. Delegated, the inference-interface ruling; embeddings are the carve-out and read Ceded at Layer 1B.
Endpoints whose request and response shapes are the provider's own (the documentation notes SageMaker models 'don't have standard input or output formats'). The enterprise holds the account, but the binding is single-provider: Ceded to the provider, the single-vendor interface reading (proprietary third-party models read Ceded to their owner); Confluent is the API client here, not a reseller. Ruled September 15, 2026: the split stands; the alternative, the whole component Delegated on the enterprise's ownership of the account and the model choice, was declined because account ownership is a procurement fact and the statement doesn't move today.
Tool logic the enterprise writes against a multi-vendor interface (Apache Flink's UDF API) or hosts itself behind MCP. Retained, the customer-created tools ruling; the CREATE TOOL wrapper that names them is Confluent's. Enterprise-hosted A2A agents are the same shape once the integration leaves Open Preview.
Confluent-hosted MCP endpoints exposing Confluent Cloud's own resources to the enterprise's assistants under the caller's RBAC. Vendor-hosted MCP over captive tools: Ceded, the Snowflake and VAST reading.
Code the enterprise runs on its own machine against Confluent Cloud, Platform, or plain Kafka. Open source the enterprise operates: Retained on portability; the tools act on Confluent resources.
Flink Native Inference runs open-source models (the documentation's examples are Phi-3.5-mini and bge-large) and the TimesFM and IBM Granite time-series models on GPUs Confluent hosts in three AWS regions. Early Access, unscored; a dependency Confluent carries, not the customer.
Confluent's runtime is Flink with AI verbs. CREATE MODEL registers a remote model from the enterprise's own account (Anthropic, AWS Bedrock, SageMaker, Azure OpenAI, Azure ML, Fireworks AI, Google AI, OpenAI, Vertex AI) and ML_PREDICT, AI_COMPLETE, and AI_EMBEDDING call it per row; ML_FORECAST and ML_DETECT_ANOMALIES run statistical models in the engine (generally available August 2025). CREATE TOOL wraps a Flink user-defined function or a Model Context Protocol (MCP) server (with an allowed-tools list), and in Open Preview an Agent2Agent (A2A) endpoint; CREATE AGENT (Streaming Agents, preview August 2025, Open Preview October 2025, generally available May 19, 2026 with a four-nines service level agreement (SLA)) declares a function-call agent from a model, a prompt, and tools, and AI_RUN_AGENT runs it over every event in a stream, with the runtime managing the reasoning-and-tool loop, retries, context trimming or summarization, a session store, and replay of every interaction against historical events; the Agent Management Console (generally available May 2026) creates and monitors agents without SQL; Streaming Agents support Anthropic, Gemini, and OpenAI models. In preview: reflection agents (drafter-critic loops, Open Preview April 2026), system log tables (Open Preview), A2A integration (Open Preview, Q1 2026), AI_TOOL_INVOKE, managed models on Confluent GPUs (Early Access), AI_DETECT_PII and AI_SENTIMENT (Early Access), TimesFM and Granite forecasting and anomaly detection (Early Access), and Confluent Copilot (Early Access). Around the runtime: Confluent's managed MCP servers (generally available May 2026) expose Confluent Cloud's own resources to the enterprise's assistants, and the open-source MCP server (MIT) does the same from the enterprise's machine (Confluent's agent skills, Apache 2.0 packs for coding assistants, are developer enablement and are named at Layer 3). The buyer gets agents that run where the events are, on the models it already pays for, with replay. The architect's concern is what isn't there and how new the rest is. Confluent serves no model in production; every inference is a call to the enterprise's provider or an Early Access managed model. The agent runtime is four months past general availability with its self-correction, cross-agent, and tool-invocation surfaces in preview, and it offers no documented gate between a model's decision to call a tool and the call. Calibration: Databricks, Snowflake, and Palantir read strong on serving plus generally available agent runtimes with evaluation; Elastic was held moderate on first-release maturity (no evaluation surface, tracing in preview); Qlik reads moderate on turnkey agents without serving; Cohere strong on its own frontier serving. Confluent has Elastic's maturity profile without serving. Moderate, on rule 5.
Split at the model, captive at the agent. Model access is split by interface: OpenAI-compatible and Anthropic Messages endpoints on the enterprise's own accounts are Delegated (the inference-interface ruling), while the Bedrock, SageMaker, Azure ML, Google AI, and Vertex bindings are provider-native and are Ceded to the provider on the single-vendor interface reading (ruled September 15, 2026: the CREATE MODEL statement and its mappings don't move to another provider today, and account ownership is a procurement fact). User-defined functions the enterprise writes as tools are its own code against Apache Flink's function interface, a multi-vendor interface: Retained, the M4 customer-tools reading; MCP servers the enterprise hosts are Retained on the same ruling. The Streaming Agent, tool, and model definitions, the AI_ and ML_ functions, the session store, and replay are Confluent's Flink extensions: Ceded. Confluent's managed MCP servers over Confluent's own resources are vendor-hosted MCP exposing captive tools: Ceded. The decision to act is the model's inside the loop, and the enterprise's only controls are bounds (max_iterations, max_consecutive_failures, allowed_tools) and its own downstream consumers of the output topic; no pre-effect gate is documented for a tool call. Model decides, visible (replay and log tables), not overridable, Ceded, the Perplexity and Cohere reading.
Unscored on their badges: reflection workflows and system log tables (Open Preview), A2A (Open Preview), AI_TOOL_INVOKE (preview), managed models (Early Access), AI_DETECT_PII and AI_SENTIMENT (Early Access), AI_FORECAST and AI_DETECT_ANOMALIES with TimesFM and Granite (Early Access), Confluent Copilot (Early Access). Documentation conflict noted: the Flink functions reference carries a preview note only on AI_TOOL_INVOKE, while the release notes and quarterly posts badge AI_DETECT_PII, AI_SENTIMENT, and the time-series functions as Early Access; the dated release note is taken as governing. The open-source MCP server is 'community-supported ... best-effort only' per its docs page, although the Q1 2026 post announced vendor support; the docs page governs. A2A: the Q1 2026 post says Open Preview, the current agent runtime guide and CREATE TOOL reference carry no badge, and the release notes never mention it; nothing public says generally available, so it stays unscored with the conflict noted. Public evidence that moves the cell: managed models generally available (serving), and a documented pre-effect gate on tool calls (authority).
Policy-driven placement and resource coordination — the Autonomy Layer
Nothing at this layer is a scored capability.
Read against the five legs the instrument asks of an Intelligence-2C plane, Confluent has none in production as a plane of its own. Identity: a Streaming Agent runs under the Flink principal's role (FlinkDeveloper or equivalent) and a service account, and the Real-Time Context Engine and the managed Model Context Protocol (MCP) servers return only what the caller's API key can see; there's no agent principal. Gateway: Confluent Gateway (generally available November 2025) proxies the Kafka protocol and, in Early Access, enforces schemas centrally; it doesn't sit in front of agent requests. Registry: the Agent Management Console creates, configures, deploys, monitors, and edits Confluent's own Streaming Agents, a product's directory of its agents (the Cohere and Anthropic reading), not a registry across the enterprise's agents. Orchestration: Agent2Agent (A2A) integration for Streaming Agents is Open Preview (the Q1 2026 post; the current runtime guide documents A2A tools without a badge, and nothing public says generally available), agents-as-tools and reflection are Open Preview (release notes, April 20, 2026; the May 19 general-availability note doesn't lift them, though the Q2 post's GA paragraph mentions the reflection pattern), and Kafka topics are the bus between agents, which is coordination infrastructure the enterprise designs rather than a plane that governs it. Observability: replay of every interaction is generally available with the runtime, system log tables are Open Preview, and audit logs cover Confluent resources; that's the runtime's own observability, the Cloudera Agent Studio reading. What Confluent does give the reasoning plane is the substrate a governor would want: an immutable, replayable event log with role-based access control (RBAC), audit, schema contracts, and the Context Engine as a governed context source over MCP. The architect's concern is the same one the Streaming Agents cell names: the loop is inside Flink, the gate is absent, and the governance that exists is governance of Confluent resources, not of agents as principals. Calibration: Cloudera reads gap with agent governance inside Agent Studio; MongoDB gap with a single-resource agent principal escalated; Qlik gap, MCP-first; Elastic and Snowflake moderate on three or more legs. Confluent is Cloudera's shape with a stronger audit substrate. Gap, authority Absent (the runtime's own controls are read at 2B).
Nothing offered as a plane; nothing inherited beyond what the 2B runtime already cedes. The enterprise that wants agent identity, a request gateway, a registry, or cross-agent governance over Streaming Agents brings its own, and the peers that supply it (an identity provider, a gateway, a registry) are substitutable. Absent.
Named, not scored: A2A integration (Open Preview per the Q1 2026 post; badge-less in current docs), system log tables (Open Preview), Confluent Gateway's centralized governance enforcement (Early Access, July 2026), reflection agents (Open Preview per the April 20, 2026 release note; the Q2 post's GA paragraph mentions reflection, and the docs badge governs). The Real-Time Context Engine's RBAC and audit are read at 1B. Public evidence that moves the cell: a first-class agent principal with scoped credentials, a request-time gateway for agents, and A2A reaching general availability would together argue moderate; any one alone is a leg, not a plane.
AI-powered business capabilities — business logic, workflow automation
Nothing at this layer is a scored capability.
Confluent sells infrastructure and no business application, and its own assistants haven't shipped. The Confluent AI Assistant in the Cloud Console, documentation, and Support Portal is 'available as Preview feature' with pricing to be announced before general availability; AI-Assisted Troubleshooting for connectors is Preview; Confluent Copilot, the hosted natural-language operator that restarts connectors with explicit confirmation, is Early Access (Q3 2026). The Data Portal is a governance surface (Layer 1A), Stream Designer was retired, and the customer-facing stories (an agentic security operations center, a city council's consent workflow) are things customers built on Kafka and Flink. The buyer gets nothing to log into at this layer. The architect's concern is nil: there's no application to be captured by. Calibration: Redis reads gap with a Beta Copilot; MongoDB moderate on a generally available assistant plus Charts (escalated); Cloudera moderate on visuals and a workbench copilot; Qlik and Snowflake strong on first-party value planes. Every Confluent assistant is pre-GA, so the developer-assistant question the MongoDB and Redis sheets raise doesn't reach this cell. Gap, Absent.
Nothing offered, nothing inherited. Absent.
Watch-list, notes only, no GA dates: Confluent AI Assistant (Preview; 'Pricing and tiers will be communicated before general availability'), AI-Assisted Troubleshooting for connectors (Preview), Confluent Copilot (Early Access). Ruled September 15, 2026: gap stands under the Layer 3 marketplace ruling (the grade rests on first-party business applications) and the features-transcend-layers rule (Streaming Agents is an agent runtime, scored at 2B); the ChatGPT pass had argued Streaming Agents as a Layer 3 workflow surface and voted moderate. Developer enablement named here, unscored: Confluent agent skills (Apache 2.0 skill packs for coding assistants; the documentation says they deploy nothing and change no resources). Public evidence that moves the cell: any of the three reaching general availability in the documentation would argue the MongoDB question; a business application would settle it.
Confluent Cloud documentation (release notes through September 9, 2026; Kafka cluster types; connectors overview and support policy; Stream Governance overview and packages; Stream Catalog, Stream Lineage, Data Portal, data contracts; Tableflow overview, catalog integration, limitations; Cluster Linking; networking; RBAC; Unified Stream Manager; Confluent Cloud for Apache Flink overview and concepts; external tables and vector search; AI and ML in Confluent Cloud; Streaming Agents overview, agent runtime guide, reflection workflows, Agent Management Console; CREATE AGENT, CREATE TOOL, CREATE MODEL; model inference and ML functions; AI_TOOL_INVOKE; run a remote AI model; run a managed AI model; Real-Time Context Engine overview, limitations, access control; managed MCP servers, open-source MCP server, agent skills; Confluent AI Assistant release notes; AI-assisted connector troubleshooting; regions); Confluent Platform documentation (overview; release notes 8.3; installation overview; Confluent Platform for Apache Flink overview; Confluent for Kubernetes overview and release notes 3.3.0); WarpStream documentation (overview, architecture); Confluent blog (IBM to Acquire Confluent, December 8, 2025; Introducing Confluent Private Cloud, October 2025; Introducing Confluent Platform 8.2 and 8.3; New in Confluent Intelligence Q1, Q2, and Q3 2026; New in Confluent Cloud Q2 and Q3 2026); Confluent Community License FAQ; the confluentinc/mcp-confluent (MIT) and confluentinc/agent-skills (Apache 2.0) repositories; IBM press release on the completed acquisition (March 17, 2026). Peer-reviewed cell by cell through the labs claims ledger (confluent-<layer>-chatgpt, ChatGPT gpt-5.5) and as a whole row by Antigravity (confluent-row-agy); totals and escalated items in reviews/confluent-judgment.md.