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 strong: 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, whose Stream Catalog carries tags and business metadata on schemas and fields that its APIs query, govern data in motion over Confluent's topics and tables, not a general estate. Layer 1B is moderate on Flink's federated key and text 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 Retained on the possess-and-operate line (September 15, 2026).
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; code / Retained at 1A, where the catalog returns the tags the enterprise applies, vendor / Delegated at 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 (would widen 1A), and any of the preview assistants reaching general availability (Layer 3).
Layer-by-layer status: Layer 0A (Not Confluent's Layer (By Design); Confluent Cloud on the Hyperscalers, WarpStream in Your Account, Platform and Private Cloud on Your Kubernetes), Layer 0B (Not Confluent's Layer (By Design); Confluent Cloud on the Hyperscalers, WarpStream in Your Account, Platform and Private Cloud on Your Kubernetes), Layer 0C (Not Confluent's Layer (By Design); Confluent Cloud on the Hyperscalers, WarpStream in Your Account, Platform and Private Cloud on Your Kubernetes), Layer 1A (Event Log and Tableflow Tables Under a Stream Catalog With Field-Level Tags and Lineage), Layer 1B (Federated Text and Key Search From Flink Into the Enterprise's Own Stores (Vector Search in Open Preview) + 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: October 27, 2026. Version: v1.15 - 4+1 v3: Layer 0 Sub-Layers.
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 strong: 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, whose Stream Catalog carries tags and business metadata on schemas and fields that its APIs query, govern data in motion over Confluent's topics and tables, not a general estate. Layer 1B is moderate on Flink's federated key and text 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 Retained on the possess-and-operate line (September 15, 2026).
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; code / Retained at 1A, where the catalog returns the tags the enterprise applies, vendor / Delegated at 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 (would widen 1A), and any of the preview assistants reaching general availability (Layer 3).
CPUs, accelerators, servers, integrated systems, OS and hypervisor, physical plant
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, on availability rather than occupancy, 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.
Interconnects, switching and routing, network virtualization
Assessment pending
Confluent, an IBM company (Confluent Cloud + Confluent Platform + Confluent Private Cloud + WarpStream + Confluent Intelligence) ships no network fabric; the enterprise or its cloud provider supplies and runs it.
Nothing at this sub-layer is the vendor's to decide: Absent.
Arrays, storage servers and software, front-end protocols: where the data sits
Assessment pending
Confluent, an IBM company (Confluent Cloud + Confluent Platform + Confluent Private Cloud + WarpStream + Confluent Intelligence) ships no storage substrate; the enterprise or its cloud provider supplies and runs it.
Nothing at this sub-layer is the vendor's to decide: Absent.
The data itself, organized and governed: 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. The Kafka protocol surface is its own chip. The service behind it, its operations, management and configuration, is Confluent's and doesn't lift: Ceded.
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. The Kafka protocol surface in front of it is its own chip.
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. The Apache Iceberg and Delta Lake surface is its own chip. The service behind it, its operations, management and configuration, is Confluent's and doesn't lift: Ceded.
The managed registry behind an interface Redpanda and Apicurio also implement, so schemas, subjects, and compatibility settings port. The Schema Registry API surface is its own chip. The service behind it, its operations, management and configuration, is Confluent's and doesn't lift: Ceded.
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).
The catalog of streams, the lineage map, and the discovery portal. Confluent metadata with no second implementer: Ceded.
Apache Iceberg and Delta Lake have independent implementations: code and definitions written to them move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. The materialized table files are read or registered through compatible catalogs; Tableflow's materialization pipeline (topic mapping, upserts, compaction, catalog publishing) and its configuration don't lift. The service behind it is its own chip, Ceded.
The Kafka protocol has independent implementations: code and definitions written to it move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. The service behind it is its own chip, Ceded.
The Schema Registry API is Confluent's interface, and the enterprise can also run it itself from the Community License source: code and definitions written to it move to a self-run deployment, the data moves by snapshot or export, and the service's control-plane configuration doesn't lift. Delegated. Schemas, subjects, versions and core compatibility settings move to another implementation of the API (Apicurio implements the core); Schema Linking, data contracts and Confluent Cloud's access controls don't. The service behind it is its own chip, Ceded.
The Kafka protocol has independent implementations: code and definitions written to it move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. The service behind it is its own chip, Ceded.
Brokers, tiered storage, Tableflow materialization, and Schema Registry run on CPUs.
Confluent's data foundation is the log: durable, replicated topics tiered to object storage. Tableflow writes them as Apache Iceberg or Delta Lake tables into the enterprise's own buckets. Stream Governance is the catalog over that data. Schema Registry holds the schemas and compatibility modes. Stream Catalog carries tags and business metadata on schemas, fields, records, topics and connectors, and its REST and GraphQL APIs filter on them. Stream Lineage maps topics, connectors and Flink statements. The architect's concern is scope. The catalog answers what the data is for Confluent's topics and Tableflow's tables, not for the rest of the estate. Enforcement stops at the topic and schema, not the row. With 1A graded on a catalog that classifies the data, as ruled October 16, 2026, the vendor's paper is the scope: VAST's Catalog covers what VAST holds. Strong. Calibration: VAST reads strong on a catalog of tags the enterprise applies; Dataiku reads moderate on asset-level tags only; WEKA reads moderate on filesystem fields.
The enterprise applies the tags and business metadata, and the catalog returns them as written, so the half that carries the grade executes the enterprise's classification: code, visible, overridable, Retained. Portability is a separate reading: the tags live in Confluent's Stream Governance format, so those opinions are Ceded.
Tags and the REST API ship in the Essentials package; business metadata and GraphQL are Advanced, a price, not a gate. Stream Catalog's documentation carries no preview marker and no explicit GA statement.
Low-latency retrieval for RAG — vector/hybrid search, context windows
Read-only lookup joins from a stream into the enterprise's own stores, generally available since November 20, 2025. The stores are the enterprise's; the CREATE TABLE connector and search functions are Confluent's Flink extensions with no second implementer: Ceded. VECTOR_SEARCH_AGG is "an Open Preview feature in Confluent Cloud" and sits in the notes.
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.
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, in Open Preview and unscored) 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. GA evidence table (October 24, 2026): VECTOR_SEARCH_AGG ("Vector Search is an Open Preview feature in Confluent Cloud") comes out of the search-functions chip, and AI_EMBEDDING (preview since August 19, 2025, no GA affirmation) goes to notes. Both return when Confluent affirms GA.
Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering
The open Kafka engine and the enterprise's topics on it; "The Apache 2.0 License covers Apache Kafka® core." Retained on the open-source seam; Confluent for Kubernetes, the operator around it, is a Ceded chip at Layer 2A.
Managed Flink and Kafka behind Flink SQL, the Flink Table API, and the Kafka protocol. Confluent-only statements (models, agents, tools, search) are Ceded at their own layers. The Flink SQL surface is its own chip. The service behind it, its operations, management and configuration, is Confluent's and doesn't lift: Ceded.
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. The Kafka protocol surface is its own chip. The service behind it, its operations, management and configuration, is Confluent's and doesn't lift: Ceded.
Lineage is in this layer's definition; the map and the hybrid console are Confluent's: Ceded.
Kafka Connect, under Apache 2.0, and the custom connector plugins the enterprise builds, modifies or takes from a third party and uploads to Confluent Cloud, where Confluent supports only the Connect infrastructure under them. Plugin logic on Kafka Connect's multi-vendor interface runs on any Connect cluster: Retained, the customer-tools reading.
The Kafka Streams API under Apache 2.0, and the enterprise's topologies on it. Retained on the open-source seam.
Confluent's Flink distribution, "fully compatible with Apache Flink" though "not all Apache Flink features are supported," licensed under the Confluent Enterprise license rather than Apache 2.0. The Flink SQL surface is its own chip. Confluent's distribution and its proprietary management layer, which the enterprise operates, don't lift: Ceded.
The Kafka protocol has independent implementations: code and definitions written to it move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. The service behind it is its own chip, Ceded.
Flink SQL has independent implementations: code and definitions written to it move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. Confluent Cloud supports Flink SQL and the Table API, not the DataStream API or custom JARs, so statements written to the common Flink SQL core move to another Flink. The service behind it is its own chip, Ceded.
Flink SQL has independent implementations: code and definitions written to it move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. The service behind it is its own chip, 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 in function (arbitrary code, insertable stages, any destination), and the best shipping implementation on the instrument for data in motion. 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: the services read Ceded, and the protocol and Flink SQL are Delegated doors. 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. Not scored within this chip under the GA evidence table: Cost Allocation ("Cost allocation is now available as an Early Access feature in Confluent Cloud.").
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. Out of the Confluent Cloud Cluster and Compute Lifecycle chip under the GA evidence table (October 24, 2026): Cost Allocation ("Cost allocation is now available as an Early Access feature in Confluent Cloud.").
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. Not scored within this chip under the GA evidence table: AI_COMPLETE, AI_EMBEDDING ("AI_COMPLETE as a native Flink function is available for preview.").
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 a maturity gate.
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). Out of the Streaming Agents and Confluent Intelligence Flink Extensions chip under the GA evidence table (October 24, 2026): AI_COMPLETE, AI_EMBEDDING ("AI_COMPLETE as a native Flink function is available for preview.").
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, its single-resource agent principal read as 2B access control; 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 Atlas Charts; 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. /reconcile (October 5, 2026): Layer 3 calibration citations updated for the Layer 3 re-reads (Nutanix, VAST, VMware to partner; CoreWeave, NVIDIA, AMD to gap) and the MongoDB BI ruling; no grade or authority change on this row. /reconcile (October 5, 2026): settled escalations cleared from the published text and ruling attributions neutralized; open escalations stay named as pending a ruling. No grade, component, or authority change. /reconcile (October 5, 2026): 2C calibration citation updated for the MongoDB 2C ruling (single-resource principal read as 2B access control). No grade, component, or authority change. v1.4 (Layer 0 sub-layers, October 16, 2026): Layer 0 split into 0A Compute, 0B Network Fabric and 0C Storage Substrate by runtime decision (Keith, October 16, 2026); storage left 1A for 0C, and 1A, now Data Foundation & Governance, is graded on the catalog that classifies the data. three gap cells carrying the row's Layer 0 authority; 1A moderate to strong (graded on the catalog that classifies the data); summary edits (summary worksheet, Keith, October 16, 2026). v1.5 (October 19, 2026, /reconcile): plain-language pass: methodology rule numbers in the prose and audit notes replaced with the reasoning they stood for; no grade, chip or authority reading changed. v1.6 (October 23, 2026, /reconcile): Layer 1 research pass. 1C: split (four engines in one chip; Confluent's Flink distribution is enterprise-licensed, not Apache 2.0). Found by the Layer 1 slot cut. Grade and cell authority unchanged. v1.7 (October 23, 2026, Layer 1 managed-services pass): Tableflow to Bring Your Own Storage splits; Confluent Cloud Kafka splits; Schema Registry, Managed on Confluent Cloud splits; Confluent Server Commercial Storage Features gets a door; WarpStream BYOC splits; Confluent Cloud for Apache Flink splits; Confluent Platform for Apache Flink splits. Grade unchanged. v1.8 (October 24, 2026, /reconcile): GA evidence recorded on 1 of 3 Layer 1B chips under the GA evidence table. Grade unchanged. v1.9 (October 24, 2026, /reconcile): Layer 1B under the GA evidence table version 2: GA evidence on every chip, preview items and unaffirmed chips to notes. Grade unchanged. v1.10 (October 24, 2026, /reconcile): GA evidence recorded on 12 of 12 Layer 1A chips under the GA evidence table version 2. Grade unchanged. v1.11 (October 24, 2026, /reconcile): GA evidence recorded on 13 of 13 Layer 1C chips under the GA evidence table version 2. Grade unchanged. v1.12 (October 24, 2026, /reconcile): GA evidence recorded on 6 of 7 Layer 2A chips under the GA evidence table version 2. Grade unchanged. v1.13 (October 24, 2026, /reconcile): GA evidence recorded on 5 of 6 Layer 2B chips under the GA evidence table version 2. Grade unchanged. v1.14 (October 24, 2026, /reconcile): GA evidence table version 2.1 applied: 2 chips recorded or narrowed. Grade unchanged. v1.15 (October 27, 2026): each component now carries a durable offering id; nothing else changed.