{
  "id": "redis",
  "name": "Redis (Redis Cloud + Redis Software + Redis Open Source + Redis Iris)",
  "subtitle": "Mapped to the 4+1 Layer AI Infrastructure Model",
  "version": "v1.0 - 4+1 v2: Authority Split",
  "date": "September 5, 2026",
  "source": "Redis documentation (Redis 8.0 and 8.8 what's new; vector sets; Redis Query Engine and FT.HYBRID; LangCache; Redis Feature Form; Redis Cloud Bring Your Own Cloud, shared responsibility, Pro sizing and clustering; Redis Data Integration overview, data pipelines, and RDI in Redis Cloud; Flex; Redis Enterprise for Kubernetes and Active-Active; cluster command compatibility; Redis Functions; Redis Insight and the Redis Copilot FAQ; licenses) and product pages (Redis for AI, Redis Iris, LangCache, Context Retriever, Agent Memory, Data Integration, Flex, Query Engine); Redis blog (Context is all you need: introducing Redis Iris, May 18, 2026; RDI in Redis Cloud GA on AWS, June 8, 2026; Introducing Redis Feature Form, April 20, 2026; What's new in two for March, April, May, and June 2026; LangCache public preview, September 2025; Redis 8 GA and the AGPLv3 license, May 2025; vector sets, April 2025; Azure Managed Redis GA, May 2025; langgraph-checkpoint-redis; Redis Copilot); Redis Software release notes on the discontinued Triggers and Functions preview; the redis/agent-memory-server (Apache 2.0), redis/mcp-redis (MIT), redis/agent-skills, and redis-field-engineering/redis-cloud-autoscaler repositories; Redis passes $300M ARR (January 2026). Peer-reviewed cell by cell through the labs claims ledger (redis-<layer>-chatgpt, ChatGPT gpt-5.5) and as a whole row by Antigravity (redis-row-agy); totals and escalated items in labs/reviews/redis-judgment.md.",
  "status": "complete",
  "summary": {
    "title": "Summary Finding",
    "paragraphs": [
      "Redis is the hot state under the agent, and the map reads it as a data platform whose AI story is one layer deep in production and three layers deep in preview. Layer 1B is moderate, escalated, on hybrid retrieval in the open-source engine (the Redis Query Engine with FT.HYBRID, generally available in Redis 8.4 and on Redis Cloud since March 2026) without a generally available embedding or reranking model beside it; 1A, 1C, and 2A are moderate on an in-memory system of record with Active-Active geo-distribution, Flex tiering, and a generally available ML feature store, on Redis Data Integration's change data capture (CDC) into Redis, and on cluster management with a Kubernetes operator; four layers are gaps: no substrate, no model serving or agent runtime (the Model Context Protocol server and Lua Functions are a tool surface and database logic, not a runtime), no reasoning plane, and no application beyond a client whose assistant is Beta.",
      "The capture is light at the engine and heavier above it. Redis Open Source has carried an Open Source Initiative license again since Redis 8 (May 2025), so the engine, the Query Engine, Streams, cluster mode, RedisVL, the LangGraph checkpointer, and the MCP server lift with the enterprise (Retained), and Redis Cloud is a managed service over that engine (Delegated); what's Redis's is Redis Software and its operator, Active-Active, Flex, the enterprise-scaled search, RDI, and Feature Form (Ceded). Seventeen components read Retained 5, Delegated 2, Ceded 10. The decision-authority readings are Delegated at 1A and 1B, where Redis's engine decides placement, eviction, and ranking subject to the per-object and per-request overrides the enterprise sets, and Retained at 1C, where RDI executes the pipeline jobs the enterprise declared.",
      "The buyer's trade: sub-millisecond state and retrieval for agents on an engine they can run themselves, in exchange for a movement layer with one destination and a preview shelf that holds most of the agent story: Redis Iris (May 18, 2026) with Context Retriever and Agent Memory in preview, LangCache in public preview since September 2025, vector sets in beta since Redis 8, and Redis Copilot in Beta. Nearly everything that would move a cell has a badge to earn: LangCache and Context Retriever reaching GA (2B and 2C), a data-estate catalog (1A), or a destination beyond Redis (1C)."
    ]
  },
  "layers": [
    {
      "id": "layer0",
      "label": "Layer 0",
      "shortName": "Compute",
      "title": "Compute & Network Fabric",
      "purpose": "Raw compute, networking, and acceleration fabric",
      "status": "gap",
      "statusLabel": "Not Redis's Layer (By Design); Redis Cloud on Redis's Cloud Accounts or Yours, Redis Software on Your Metal",
      "authority": {
        "decides": "absent",
        "visible": null,
        "overridable": null,
        "boundary": "vendor",
        "direction": "Absent"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Dependency",
          "detail": "Redis runs on general-purpose compute and memory. The inference in Redis's product line (LangCache's default embedding models, in preview; Redis Copilot, a Beta developer tool on the OpenAI API) is Redis-hosted and undisclosed as to accelerator; none of it is scored here."
        }
      ],
      "gap": "Redis sells no silicon, fabric, or arrays. Redis Cloud runs on Amazon Web Services (AWS), Azure, and Google Cloud in Redis's own cloud accounts by default, or in the customer's account under Bring Your Own Cloud (BYOC), where Redis still deploys, scales, monitors, and supports the databases through an Identity and Access Management (IAM) role the customer can revoke and the customer pays the cloud provider directly for the infrastructure; the customer chooses provider, region, and availability zone, and Redis chooses the instance family and operates the resources. Azure Managed Redis (generally available May 2025) is a first-party Microsoft service co-engineered with Redis; Redis Software runs self-managed on whatever the enterprise owns, on virtual machines or through the Redis Enterprise for Kubernetes operator, with Flex requiring the enterprise to plan local NVMe flash and separate persistence disks; Redis Open Source runs anywhere. The company passed $300 million in annual recurring revenue in January 2026 with 12,000 paying customers, and the split between Cloud and Software isn't disclosed. On the managed paths the buyer never thinks about Layer 0; on the self-managed path the enterprise plans it.\n\nApplying the exposure test: on Redis Cloud the fleet is Redis's (even under BYOC the customer is told not to touch the Redis-managed VMs and VPCs); on Redis Software and Open Source the substrate is the enterprise's own.\n\nCalibration: Elastic and MongoDB read gap with authority Absent for vendors with first-party hosted and self-managed production paths (rule 7, availability not occupancy); Snowflake and Databricks read Ceded with no self-managed path; Kamiwaza and Cloudera Absent on customer infrastructure. Redis is the Elastic and MongoDB case. Gap, Absent, with Redis Cloud named as Ceded-invisible for the customers who take it.",
      "borrowedJudgment": "None on the self-managed path; on Redis Cloud, instance family, placement inside the customer's chosen zone, and the Flex flash hardware are Redis's choices seen as a plan and a tier. Absent, the Elastic and MongoDB reading.",
      "notes": "Public evidence that moves the cell: a Redis-owned or Redis-sold compute product.",
      "components": []
    },
    {
      "id": "layer1a",
      "label": "Layer 1A",
      "shortName": "Storage",
      "title": "Data Storage & Governance",
      "purpose": "Durable, governed data foundation — the Governance Catalog that Layer 2C queries",
      "status": "moderate",
      "statusLabel": "In-Memory System of Record for Hot State, Geo-Distributed and Tiered, With an ML Feature Store; No Data-Estate Catalog",
      "authority": {
        "decides": "vendor",
        "visible": true,
        "overridable": true,
        "boundary": "vendor",
        "direction": "Delegated"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Layer 1A Dependency",
          "detail": "Nothing at this layer runs on accelerators."
        }
      ],
      "gap": "Redis is where the hot state of an application, and now of an agent, lives. Redis 8 folded what used to be modules into the core under an Open Source Initiative license: hashes, strings, lists, sets, sorted sets, streams, JSON documents, time series, probabilistic structures, and (in 8.8, generally available in Open Source in May 2026) an Array type, with the Redis Open Source tri-license offering AGPLv3, RSALv2, or SSPLv1. Above the engine, Redis Software and Redis Cloud add the enterprise data management: Active-Active geo-distribution with conflict-free replicated data types across regions and Kubernetes clusters; Flex tiering that keeps hot data in RAM and warm data on flash at a tunable 10 to 50 percent RAM ratio (extended to BYOC in June 2026), with a documented gate that Flex databases can't yet use Redis Search, Time Series, or Active-Active; persistence and backups; role-based access control (RBAC) with key-level access control lists (ACLs), Transport Layer Security (TLS), certificate-based authentication with LDAP or Active Directory authorization (Redis Software, May 2026), and auditing; AWS PrivateLink (generally available May 2026); dynamic endpoints for migrations (public preview). Redis Feature Form (generally available April 20, 2026, from the Featureform acquisition) is a managed feature store for production machine learning: feature definition, batch and streaming pipeline orchestration, versioning, atomic updates to the feature dependency graph (DAG), lineage, workspace multi-tenancy, RBAC and audit logs, and sub-millisecond online serving from Redis. The buyer gets a sub-millisecond system of record for operational, agent, and feature state, replicated across the world, with the durability and tiering that turn a cache into a store.\n\nWhat's missing is the estate. Feature Form catalogs and traces ML features; there's no catalog, lineage, or classification over data as an enterprise estate that Layer 2C could query, and the data Redis holds is the working set, not the system of record behind it (RDI, at 1C, exists because the record lives elsewhere).\n\nCalibration: Snowflake and Databricks read strong on governed lakehouses with catalogs; Elastic and MongoDB moderate on durable stores with access governance and no catalog; Cloudflare moderate on an S3 store and edge databases. Redis is the Elastic and MongoDB case with a feature catalog on top. Moderate.",
      "borrowedJudgment": "Split by path. Redis Open Source under the AGPLv3 option is open source the enterprise runs itself: Retained, the Elastic core reading. Redis Cloud is a managed service over that open engine, substitutable with the enterprise's own deployment at the cost of the managed features: Delegated, the Elastic Cloud Hosted and Atlas reading; BYOC and Azure Managed Redis are the same service in another account or through another operator. Redis Software, Active-Active, Flex, the enterprise security features, and Feature Form are Redis's proprietary layer wherever they run: Ceded. The runtime tradeoff is Redis executing the data structures, ACLs, and eviction policies the enterprise set, with every knob exposed: vendor decides, visible, overridable, Delegated.",
      "notes": "Watch-list, notes only: dynamic endpoints (public preview); Redis 8.8 features arriving in Redis Cloud and Redis Software (expected late summer 2026). Public evidence that moves the cell: a data-estate catalog, lineage, or classification product on Redis's paper.",
      "components": [
        {
          "component": "Redis Open Source, Self-Run (Redis 8.x; AGPLv3 Option; Core Data Structures, JSON, Time Series, Probabilistic, Streams, Array)",
          "detail": "The engine the enterprise runs itself under an OSI license since Redis 8 (May 2025), with the former modules in the core. Open source the enterprise operates: Retained.",
          "dapm": "Retained"
        },
        {
          "component": "Redis Cloud (Managed on AWS, Azure, Google Cloud; Essentials and Pro; BYOC; Azure Managed Redis)",
          "detail": "The managed service over the open engine, in Redis's accounts, the customer's (BYOC), or Microsoft's. Substitutable with a self-run deployment: Delegated.",
          "dapm": "Delegated"
        },
        {
          "component": "Redis Software (Commercial Self-Managed Platform: Cluster Manager, Enterprise Security, Certificate and LDAP Authentication, Auditing)",
          "detail": "The proprietary enterprise platform around the engine, on the customer's infrastructure. Redis's: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "Active-Active Geo-Distribution (CRDTs Across Regions and Kubernetes Clusters)",
          "detail": "Conflict-free multi-region read and write on Redis Cloud and Software. Redis's replication technology: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "Flex (RAM-to-Flash Tiering, Tunable 10 to 50 Percent RAM; BYOC Pricing Since June 2026; Not Yet With Search, Time Series, or Active-Active)",
          "detail": "Larger effective datasets at lower cost on Redis Cloud and Software, with the compatibility gate named. Redis's tiering: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "Redis Feature Form (Managed ML Feature Store; GA April 20, 2026: Definition, Orchestration, Versioning, Lineage, Workspaces, RBAC, Online Serving)",
          "detail": "The feature platform from the Featureform acquisition, governing ML features from definition to serving. Redis's: Ceded.",
          "dapm": "Ceded"
        }
      ]
    },
    {
      "id": "layer1b",
      "label": "Layer 1B",
      "shortName": "Retrieval",
      "title": "Context Management & Retrieval",
      "purpose": "Low-latency retrieval for RAG — vector/hybrid search, context windows",
      "status": "moderate",
      "statusLabel": "Native Hybrid Retrieval in the Open Engine, Without GA Models; Semantic Caching, Vector Sets, Context Retriever, and Agent Memory in Preview",
      "authority": {
        "decides": "vendor",
        "visible": true,
        "overridable": true,
        "boundary": "vendor",
        "direction": "Delegated"
      },
      "nvidia": [
        {
          "component": "No Customer-Side NVIDIA Dependency",
          "detail": "Vector search runs on CPU in the engine; the embedding models behind the preview LangCache are Redis-hosted and unscored."
        }
      ],
      "gap": "Retrieval is in the engine, and since Redis 8 it's in the open-source engine. The Redis Query Engine (the former RediSearch, now core under the tri-license) indexes hashes and JSON for full-text, numeric, geographic, and tag queries and for vector similarity with HNSW and flat indexes, quantization, and dimension controls (JSON float-precision controls in 8.8 cut vector memory by up to 92 percent); hybrid search through FT.HYBRID (generally available in Redis 8.4, on Redis Cloud since March 2026) fuses vector similarity with lexical and structured filters in one command; the query scaling once exclusive to Redis Cloud and Software (multi-threaded queries, vertical scaling) is in the open engine, and Redis Software adds enterprise-scaled search with Active-Active. Around it: RedisVL, the open-source vector library, and langgraph-checkpoint-redis for thread and cross-thread agent memory. The preview shelf is long: vector sets (a data type by Redis's creator for similarity search on the sorted-set model, beta since Redis 8), LangCache (a managed semantic cache on Redis Cloud, public preview since September 2025), and Redis Iris (May 18, 2026), which rolls retrieval, memory, integration, and caching into a context engine for agents with its two new pieces, Context Retriever (a semantic model over business entities that auto-generates MCP tools with scoped keys and server-side row filters) and Agent Memory (short- and long-term memory as a managed service, with an Apache 2.0 reference implementation on GitHub that Redis says isn't the supported production path), both in preview. The buyer gets vector and hybrid retrieval next to the state their agents already keep in Redis, at Redis latency, self-run or managed.\n\nThe architect's concern is the embedding space and the working set. Redis stores vectors it didn't make; whichever model made them owns the space under the carve-out. The index lives in memory (or Flex, which doesn't yet support Search), which is the point and the bill.\n\nCalibration: Elastic and MongoDB read strong on native hybrid retrieval engines with self-run cores and generally available embedding and reranking models (ELSER and Elastic Rerank; Voyage); Snowflake strong on managed retrieval with Arctic Embed and a semantic layer; Cloudflare moderate on an index plus open models; Cohere moderate on frontier models plus a managed bundle. Redis has Elastic's engine without Elastic's models: the hybrid engine is generally available and the embedding, reranking, and caching pieces are in preview. Moderate, with the escalation recorded: strong argued on the engine alone.",
      "borrowedJudgment": "Low at the engine, split above it. The Query Engine, RedisVL, and the LangGraph checkpointer are open source the enterprise runs: Retained; the same engine operated on Redis Cloud is Delegated; Redis Software's enterprise-scaled search and Active-Active are proprietary, Ceded. The enterprise composes the index, the filters, and the fusion: vendor decides at the engine, visible, overridable, Delegated, the Elastic reading.",
      "notes": "Escalated: the grade (moderate written; strong argued on a generally available open hybrid engine with FT.HYBRID). Watch-list, notes only, and this is what deepens the cell: Redis Iris (launched May 18, 2026 on Redis Cloud) with Context Retriever and Agent Memory in preview; the Apache 2.0 agent-memory-server reference implementation (V0, not the supported production path); LangCache (public preview since September 2025, with only Redis and OpenAI embedding providers during preview); vector sets (beta since Redis 8.0, APIs may change). Public evidence that moves the cell: LangCache or a Redis-hosted embedding and reranking service reaching GA.",
      "components": [
        {
          "component": "Redis Query Engine in Redis Open Source (Vector, Full-Text, Hybrid FT.HYBRID, JSON; AGPLv3 Option)",
          "detail": "Native vector and hybrid retrieval in the open-source engine the enterprise runs itself. Retained on the open-source seam, the Elastic retrieval-core reading.",
          "dapm": "Retained"
        },
        {
          "component": "Redis Search on Redis Cloud (Managed Open Query Engine)",
          "detail": "The same engine operated by Redis on Redis Cloud. Managed service over an open engine: Delegated.",
          "dapm": "Delegated"
        },
        {
          "component": "Redis Software Enterprise-Scaled Search + Active-Active Search",
          "detail": "The proprietary platform's scaling and geo-distribution around the engine, on the customer's infrastructure. Redis's: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "RedisVL + langgraph-checkpoint-redis (Open-Source Libraries)",
          "detail": "The vector library and the LangGraph memory checkpointer and store, open source in the enterprise's own code. Retained.",
          "dapm": "Retained"
        }
      ]
    },
    {
      "id": "layer1c",
      "label": "Layer 1C",
      "shortName": "Pipelines",
      "title": "Data Movement & Pipelines",
      "purpose": "Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering",
      "status": "moderate",
      "statusLabel": "RDI: CDC Into Redis, Self-Hosted From Eleven Sources or Managed on Redis Cloud From AWS Sources; One Destination",
      "authority": {
        "decides": "code",
        "visible": true,
        "overridable": true,
        "boundary": "vendor",
        "direction": "Retained"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Layer 1C Dependency",
          "detail": "Nothing at this layer runs on accelerators."
        }
      ],
      "gap": "Redis moves data one way: in. Redis Data Integration (RDI) does an initial bulk hydration of a source into Redis and then continuous change data capture (CDC) that keeps Redis in sync, with transformations the enterprise declares in YAML jobs (mapping, key patterns, output structures) that turn source rows into Redis data structures; self-hosted and Helm deployments read Oracle, PostgreSQL, MySQL, MariaDB, SQL Server, MongoDB, Spanner, AlloyDB, Aurora, Neon, and Supabase, with Snowflake in preview for reverse-ETL and feature-store patterns; RDI 1.18 (May 2026) added a Flink-based processor with up to 3.4 times the ingest throughput and 20,000 CDC events a second, and an API for dead-letter inspection, target flushes, and readiness checks. RDI in Redis Cloud reached general availability on AWS on June 8, 2026 as a fully managed service with self-service pipelines, private connectivity, and Terraform, reading AWS-hosted sources (RDS, Aurora, EC2), MongoDB Atlas, and Snowflake (preview) into a Redis Cloud Pro target. Redis Streams carry events inside the platform with consumer groups, and 8.8's XNACK makes failure handling explicit. Redis Insight builds and tests pipelines without code, and Redis Feature Form (generally available April 20, 2026) orchestrates batch and streaming feature pipelines with backfills and feature lineage into Redis for machine learning. The buyer gets a system of record synced into a sub-millisecond serving layer without owning the CDC stack.\n\nThe architect's concern is rule 4's coverage test, and Redis says it itself: RDI \"is not intended to be a general solution for all data integration tasks.\" Sources are broad; the destination is Redis. There's no extract-transform-load to anywhere else, no data lineage beyond Feature Form's lineage over ML features, no cost-aware movement, and no KV-cache tiering (Flex tiers data, not model caches).\n\nCalibration: MongoDB reads moderate on streams and CDC with fixed destinations; Elastic moderate on ingest fleets without CDC; Snowflake, Databricks, and Qlik strong on any-to-any movement; Cloudflare moderate on queues and workflows. Redis is MongoDB's shape with more sources and a single destination. Moderate.",
      "borrowedJudgment": "Low. The pipeline jobs are the enterprise's declarations executed by RDI's Debezium- and Flink-based runtime with no judgment of Redis's own in the transformation: code decides, visible, overridable, Retained, the MongoDB and Cloudflare 1C reading. RDI is commercial software under the Redis Software terms wherever it runs, and Feature Form's pipelines are Redis's: Ceded. Streams are the open engine's: Retained.",
      "notes": "Watch-list, notes only: Snowflake as an RDI source (preview); RDI in Redis Cloud on Azure and Google Cloud (AWS only at GA). Reviewed for awareness: the authority reading follows MongoDB's and Cloudflare's code / Retained for engines that execute enterprise-declared jobs; Snowflake's and Cloudera's NiFi rows read vendor / Delegated, and the split is on the reconcile list. Public evidence that moves the cell: a destination beyond Redis, or data lineage beyond ML features.",
      "components": [
        {
          "component": "Redis Data Integration, Self-Hosted and Helm (Bulk Hydration + Continuous CDC From Eleven Sources; Enterprise-Declared YAML Jobs; Flink Processor Since 1.18)",
          "detail": "The commercial CDC and transformation product that syncs systems of record into Redis. Redis's, under the Redis Software terms: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "RDI in Redis Cloud (Fully Managed; GA on AWS June 8, 2026; AWS-Hosted Sources, MongoDB Atlas, Snowflake Preview; Redis Cloud Pro Target)",
          "detail": "The managed edition of RDI inside Redis Cloud. Redis's service: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "Redis Streams (Consumer Groups, XNACK) in Redis Open Source",
          "detail": "Event movement inside the platform in the open engine. Retained on the open-source seam.",
          "dapm": "Retained"
        },
        {
          "component": "Redis Feature Form Pipelines (Batch and Streaming Feature Orchestration, Backfills, Feature Lineage)",
          "detail": "The feature store's pipeline orchestration and lineage over ML features flowing into Redis (GA April 20, 2026). Redis's: Ceded.",
          "dapm": "Ceded"
        }
      ]
    },
    {
      "id": "layer2a",
      "label": "Layer 2A",
      "shortName": "Orchestration",
      "title": "Infrastructure Orchestration",
      "purpose": "GPU scheduling, quotas, RBAC, fair-share scheduling, utilization optimization",
      "status": "moderate",
      "statusLabel": "Cluster Management, Kubernetes Operator, Managed Sizing, and Flex Tuning; No GPU Plane",
      "authority": {
        "decides": "vendor",
        "visible": true,
        "overridable": false,
        "boundary": "vendor",
        "direction": "Ceded"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Layer 2A Dependency",
          "detail": "No GPU scheduling exists on Redis's paper."
        }
      ],
      "gap": "Redis orchestrates Redis. Redis Software's cluster manager shards, rebalances, fails over, and upgrades databases across nodes; Redis Enterprise for Kubernetes (the proprietary operator, 8.0.6-8 in December 2025 with later 2026 releases) deploys clusters and Active-Active databases as custom resources across multiple Kubernetes clusters; Redis Cloud sizes databases from the dataset size and throughput the customer defines, calculates shard counts automatically, scales and patches them, and since June 2026 lets the customer tune the Flex RAM-to-flash ratio, with a field-engineering autoscaler available to run in the customer's own environment; BYOC puts the same managed lifecycle in the customer's cloud account with Redis creating the VPCs and VMs through the customer's IAM role; Redis Open Source ships its own cluster mode, with atomic slot migration (CLUSTER MIGRATION, 8.4) for zero-downtime resharding there, a command Redis Software and Redis Cloud don't expose. The buyer gets a scheduler for one system that they never operate on the Cloud path and operate lightly on the Software path.\n\nThe architect's concern: none of it schedules anything but Redis. No GPU plane, no quotas or fair-share over a shared fleet, no placement across workloads. Shard placement, sizing, and tiering are Redis's judgment within the bounds the enterprise sets.\n\nCalibration: Elastic reads moderate with authority Ceded on ECE, ECK, and Hosted autoscaling; MongoDB moderate on cluster autoscaling and operators; Snowflake moderate on managed compute with GPU pools; Cloudflare moderate on containers and dispatch. Redis is the Elastic and MongoDB shape. Moderate, Ceded.",
      "borrowedJudgment": "Bounded. Plan sizes, shard counts, throughput targets, and the Flex ratio are configuration Redis honors within its own placement and rebalancing judgment: vendor decides, visible, not overridable, Ceded. The operator and cluster manager are Redis's proprietary software; Open Source cluster mode is the enterprise's.",
      "notes": "Watch-list, notes only: the Redis Cloud Autoscaler (a field-engineering tool, not a product surface). Public evidence that moves the cell: a GPU or shared-fleet scheduling surface, or product-documented autoscaling on Redis Cloud.",
      "components": [
        {
          "component": "Redis Software Cluster Manager + Redis Enterprise for Kubernetes Operator (Proprietary; Multi-Cluster, Active-Active CRDs)",
          "detail": "Sharding, failover, upgrades, and Kubernetes lifecycle for the commercial platform on the customer's infrastructure. Redis's proprietary software: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "Redis Cloud Lifecycle (Customer-Defined Dataset Size and Throughput, Automatic Shard Calculation, Flex RAM-to-Flash Ratio, BYOC Provisioning Through the Customer's IAM Role)",
          "detail": "Managed sizing, scaling, and patching in Redis's or the customer's cloud account. Redis's control plane: Ceded.",
          "dapm": "Ceded"
        },
        {
          "component": "Redis Open Source Cluster Mode (Slot Sharding, Failover, Atomic Slot Migration Since 8.4)",
          "detail": "Sharding and failover in the open engine the enterprise operates. Retained on the open-source seam.",
          "dapm": "Retained"
        }
      ]
    },
    {
      "id": "layer2b",
      "label": "Layer 2B",
      "shortName": "Runtime",
      "title": "Application Runtime & Execution",
      "purpose": "Model serving, agent execution, inference APIs, distributed inference",
      "status": "gap",
      "statusLabel": "A Tool Surface (MCP Server) and Database Logic (Lua Functions), Not a Runtime; Semantic Caching in Preview",
      "authority": {
        "decides": "absent",
        "visible": null,
        "overridable": null,
        "boundary": "vendor",
        "direction": "Absent"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Layer 2B Dependency",
          "detail": "Redis serves no model; the preview LangCache's default embeddings are Redis-hosted and unscored."
        }
      ],
      "gap": "Redis is the runtime's memory, not the runtime. What ships at this layer's function is a tool surface and in-database logic: the Redis MCP Server (MIT, on PyPI, Docker, and GitHub, run separately from Redis and configured into the client) lets any Model Context Protocol client read and write strings, hashes, lists, sets, sorted sets, JSON, streams, and pub/sub, manage vector indexes and search, and inspect the server; Redis Agent Skills and the Cursor plugin put Redis into agent frameworks and coding agents as instructions; Redis Functions (Lua, since 7.0, supported on Software and Cloud) run application logic inside the database, while the JavaScript Triggers and Functions preview was discontinued in May 2024 without reaching general availability. The inference-path piece, LangCache, a managed semantic cache that answers semantically similar prompts from Redis before the LLM is called, has been in public preview since September 2025; Context Retriever, which auto-generates governed MCP tools from a semantic model of business entities, is in preview inside Redis Iris. Agent state itself (LangGraph checkpoints and stores, session memory, rate limits through 8.8's INCREX, streams with XNACK for agent workflows) is Redis as a database, scored at 1A and 1B. The buyer gets their hot state as a tool inside somebody else's agent runtime.\n\nApplying the test: the layer asks for model serving, agent execution, and inference APIs, and Redis ships none generally available. An MCP server points the other way, as on the Qlik row: it makes the vendor a tool for agents whose runtime lives elsewhere. Lua Functions are database programmability, not agent execution.\n\nCalibration: MongoDB reads moderate on an embedding inference API plus a managed MCP server plus triggers; Elastic moderate on an agent builder and brokered LLMs; Qlik moderate on turnkey agents; NetApp gap with the runtime being NVIDIA's. Redis has less than any of the moderates once the preview cache is set aside. Gap, Absent, with the boundary named: LangCache reaching GA would put an inference-path service on Redis's paper and argue the MongoDB reading.",
      "borrowedJudgment": "None to borrow at the layer's function: the MCP server and skills are open source the enterprise runs, exposing its own database over a standard protocol, and the runtime that calls them is somebody else's. Absent: nothing generally available offered, nothing inherited.",
      "notes": "Watch-list, notes only, and this is what moves the cell: LangCache (public preview on Redis Cloud since September 2025; Redis and OpenAI embedding providers during preview); Context Retriever (preview; auto-generated MCP tools with scoped keys and row-level filters); Agent Memory (preview) and the agent-memory-server reference implementation (Apache 2.0, V0); a hosted Redis Cloud MCP server (none documented). Public evidence that moves the cell: LangCache GA, or model serving or an agent runtime on Redis's paper.",
      "components": []
    },
    {
      "id": "layer2c",
      "label": "Layer 2C",
      "shortName": "Reasoning",
      "title": "Agentic Infrastructure — The Reasoning Plane",
      "purpose": "Policy-driven placement and resource coordination — the Autonomy Layer",
      "status": "gap",
      "statusLabel": "ACLs and Scoped Keys, Not a Reasoning Plane; Context Retriever's Governed Tools in Preview",
      "authority": {
        "decides": "absent",
        "visible": null,
        "overridable": null,
        "boundary": "vendor",
        "direction": "Absent"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Layer 2C Dependency",
          "detail": "No reasoning-plane product exists to carry a dependency."
        }
      ],
      "gap": "Redis governs access to Redis. Role-based access control and key-pattern ACLs decide what a client (or an agent holding its credentials) may read and write; certificate and LDAP authorization tie that to the enterprise's identity systems on Redis Software; auditing records it; Feature Form adds workspace-scoped RBAC and audit logs over ML features. Context Retriever, in preview, is the first agent-shaped governance: agents authenticate with scoped keys, discover only the MCP tools they're allowed to use, and execute lookups with row-level filters enforced server-side, a data-access policy at the tool boundary. Applying the test: Intelligence-2C asks which agent may act, under whose identity, within what policy, across the estate; what's generally available answers it for one resource, Redis, with the agent as a database client, and the agent-shaped answer is in preview. There's no agent registry, no gateway over tool calls to other systems, no agent principal distinct from a database user, no cross-agent orchestration, and no observability of agents. Infrastructure-2C, placement across model, cost, and compliance tiers, is absent as everywhere.\n\nCalibration: MongoDB reads gap with App Connections and MCP configurations governing access to MongoDB (escalated as a single-resource principal); Qlik gap on an MCP-first posture; Anthropic gap on runtime permissions; Elastic and Snowflake moderate on multi-leg planes. Redis is the MongoDB case a step earlier. Gap, Absent.",
      "borrowedJudgment": "None to borrow at the layer's function: ACLs are a property of the 1A store and the MCP server's reach a property of the tool surface. To the extent a reasoning plane exists in a Redis estate, the enterprise built it. Absent: nothing offered, nothing inherited.",
      "notes": "Watch-list, notes only, and this is what moves the cell: Context Retriever (preview; scoped keys, permission-filtered tool discovery, server-side row filters), which would read as governed data-source access for agents at GA, the MongoDB App Connections shape. Public evidence that moves the cell: an agent principal, a registry, or policy over calls to systems other than Redis.",
      "components": []
    },
    {
      "id": "layer3",
      "label": "Layer 3 (+1)",
      "shortName": "Applications",
      "title": "AI Application Layer — The Value Plane",
      "purpose": "AI-powered business capabilities — business logic, workflow automation",
      "status": "gap",
      "statusLabel": "Developer Tooling With a Beta Assistant; No Value Plane",
      "authority": {
        "decides": "absent",
        "visible": null,
        "overridable": null,
        "boundary": "vendor",
        "direction": "Absent"
      },
      "nvidia": [
        {
          "component": "No NVIDIA Layer 3 Dependency",
          "detail": "Nothing at this layer exists to carry a dependency."
        }
      ],
      "gap": "Redis's applications are for the people who run Redis. Redis Insight (SSPLv1 for community users, commercial for customers) is the graphical client, with a no-code RDI pipeline builder and, since 3.2, discovery and Entra ID sign-in for Azure Managed Redis; Redis Copilot, powered by the OpenAI API, answers Redis questions in the documentation (free, available now) and, inside Insight, turns everyday language into search queries over the connected database, where Redis's own FAQ says it \"is released as Beta\" and is rolling out gradually behind a Redis Cloud sign-in. The Cursor plugin and Agent Skills put Redis into other people's coding tools. Applying the test: the layer asks for AI-powered business capabilities, and what ships is a database client with a Beta assistant; nothing here runs a business process or a business user's workflow.\n\nCalibration: MongoDB reads moderate on a GA assistant plus Charts (escalated); Cloudflare gap on a crawler console; NetApp gap as a foundation beneath others' apps; Elastic strong on first-party applications. Redis has a client and a Beta assistant. Gap, Absent, with the boundary named: Copilot reaching general availability across Insight would argue the MongoDB reading.",
      "borrowedJudgment": "None to borrow at the layer's function. The applications built on Redis are the enterprise's or an ISV's, scored on their rows. Absent: nothing offered at the layer's function, nothing inherited.",
      "notes": "Escalated: the grade (gap written; moderate argued on Redis Copilot as a first-party AI surface). Watch-list, notes only: Redis Copilot in Redis Insight (Beta; gradual rollout; OpenAI-powered; Redis Cloud sign-in). Public evidence that moves the cell: Copilot GA across Insight, or a first-party application beyond the database client.",
      "components": []
    }
  ]
}