Agent memory layers come of age in Q2 2026.

From RAG-over-vector to hybrid memory architecture

The RAG-over-vector architecture, which dominated 2023-2025 production deployments, treats memory as a single homogeneous retrieval surface. An agent's queries are embedded, the embeddings are matched against a vector index, the top-k results are retrieved, and the retrieved context is concatenated into the agent's prompt. The architecture was the natural extension of the 2022-2023 embedding-and-retrieval pattern, and it shipped to production at scale through 2024 because it was operationally simple, vendor-supported by Pinecone, Weaviate, Qdrant, and Chroma, and architecturally compatible with the embedding-and-completion API surface that the model providers had standardised. The architecture worked for first-generation agent use cases — documentation lookup, customer support knowledge retrieval, internal information surface — and it broke at scale for second-generation use cases that emerged through 2025.

The first failure mode was relational reasoning. The vector store retrieves by semantic similarity, which works well for "find the document that talks about X" queries and works poorly for "find the document where person A approved decision B, then trace the dependency chain to decision C" queries. The relational queries are the ones that agent workflows in legal, compliance, healthcare, and complex customer support encounter constantly. A vector store cannot natively traverse a relational graph; it can only return the documents that semantically match a query, and the agent has to reconstruct the relationships from the retrieved documents inside its prompt. That reconstruction is fragile, expensive in context tokens, and frequently incorrect when the relationships span many documents.

The second failure mode was temporal coherence. Agent workflows that operate over time — multi-turn customer support, long-running case management, clinical decision support spanning multiple patient encounters — require memory that distinguishes between current state, historical state, and projected future state. A vector store cannot natively encode that distinction. The retrieval ranks by semantic similarity, which means the most-similar document in the index might be a document from six months ago that has been superseded by a more recent document with different content. Production agents running on RAG-over-vector produced hallucinations not because the model was hallucinating but because the retrieval surface was returning stale context that the model then incorporated faithfully. The hallucination metric was, in many post-mortem analyses, a retrieval-surface problem rather than a model-surface problem.

The third failure mode was state-machine reasoning. Agent workflows that involve multi-step execution against a defined process — onboarding a new customer, processing an insurance claim, executing a clinical care pathway — require the agent to track where in the process the current task is and what the next legitimate step is. A vector store cannot encode process state; it can only retrieve documents that describe the process abstractly. Production agents running on RAG-over-vector lost track of process state across long-running workflows, particularly when the workflow spanned multiple agent invocations across hours or days. The state-loss generated operational incidents that the engineering teams attributed initially to model hallucination but that the post-mortems traced consistently to the absence of an explicit state-machine layer in the memory architecture.

The hybrid memory architecture that has displaced RAG-over-vector in production-grade deployments addresses all three failure modes by separating memory into three layers. The first layer is the knowledge graph — typically a Neo4j, Memgraph, or TigerGraph deployment — that encodes the entities, relationships, and constraints that the agent's workflow operates against. The second layer is the vector store — typically Pinecone Serverless, Weaviate Cloud, or Qdrant Cloud — that handles semantic similarity over unstructured documents. The third layer is the short-term context — typically managed by the orchestration runtime via state checkpointing primitives like LangGraph's checkpointer or AWS Bedrock Agents' session-state surface — that maintains the current task state, the recent conversation history, and the agent's working memory for the active workflow. The three layers are queried through different patterns: graph queries for relational reasoning, vector queries for semantic retrieval, and runtime-managed state for short-term continuity. The orchestration runtime composes the three layers into the agent's context for each invocation.

The named buyers running the new pattern

JPMorgan Chase's chief technology office is the most public reference for the hybrid memory architecture. The bank's internal agent platform, which serves the firm's wealth management, investment banking, and asset management businesses, transitioned from a RAG-over-vector architecture to a hybrid architecture in late Q1 2026. The deployment uses Neo4j as the knowledge graph layer (encoding the entities and relationships across the firm's research, client, and product data models), Pinecone Serverless as the vector layer (for unstructured document retrieval across research reports, regulatory filings, and internal documentation), and an Azure AI Foundry-managed short-term context layer that tracks the active session state. The procurement-side conversation around the transition, surfaced through industry conference commentary by the bank's head of AI platform engineering, indicates that the hybrid architecture's operational cost per agent invocation runs roughly 1.3x to 1.8x the previous RAG-over-vector cost, with the cost increase offset by a roughly 40 per cent reduction in agent-loop iterations required to complete a typical workflow.

Pfizer's clinical operations technology team transitioned its internal clinical trial protocol agent to the hybrid architecture between February and April 2026. The Pfizer deployment is the most architecturally complete reference, because the clinical trial workflow requires all three memory layers and the production constraints under FDA 21 CFR Part 11 and ICH GCP guidelines made the failure modes of the previous architecture clinically unacceptable. Pfizer's deployment uses Memgraph for the knowledge graph layer (encoding the protocol structure, the eligibility criteria, the adverse-event ontology, and the cross-protocol dependency relationships), Qdrant Cloud as the vector layer, and a custom short-term context layer built by Pfizer's internal platform team on top of the orchestration runtime. The migration cost, by Pfizer's published procurement commentary, was approximately $3.8 million in engineering and vendor cost over the four-month transition window. The clinical operations team has documented a roughly 62 per cent reduction in protocol-relevance errors compared to the prior architecture.

Adobe's enterprise customer success organisation transitioned its internal customer-context agent in March-April 2026. The Adobe deployment serves the firm's enterprise customer success managers with an agent that synthesises customer health signals, product usage data, support history, and account-management context. The previous RAG-over-vector deployment had been generating customer-context briefs that were factually accurate at the individual-document level but that frequently missed the relational structure across customer interactions. The hybrid architecture, using Neo4j AuraDB for the knowledge graph layer, Pinecone Serverless for the vector layer, and LangGraph state checkpoints for the short-term context, has materially improved the relational accuracy of the customer briefs. Adobe's published commentary, communicated by the customer success technology lead at a recent industry conference, indicates that customer success manager satisfaction with the agent's briefs has risen from a 6.4 out of 10 average to an 8.1 average over the post-migration period.

SAP's internal Joule platform team has built its second-generation Joule architecture on the hybrid memory pattern, with a structural difference from the three above buyers: SAP has built the knowledge graph layer using its own internal HANA Knowledge Graph extension rather than a third-party graph database. The decision is the natural extension of SAP's strategic positioning around HANA as the primary data platform, and it produces a procurement consequence that differentiates SAP's Joule architecture from the broader market pattern. The HANA-native knowledge graph integrates more tightly with the SAP data model than a Neo4j or Memgraph alternative could, at the cost of being locked into the SAP technology stack. For SAP's internal Joule deployment and for the customer-facing Joule offering that SAP is rolling out to its enterprise customer base through Q2 and Q3 2026, the HANA-integration tightness is procurement-preferred over the more general-purpose alternative. The decision will not generalise outside the SAP customer base, but inside that customer base it is producing a structurally distinct architecture that is now the SAP-default agent memory pattern.

The four named buyers together demonstrate that the hybrid architecture pattern is not an academic exercise. It is the production-default pattern for the second-generation agent workflows that the Fortune 1000 is now deploying. The pattern is replicating across other buyers — Cisco's IT services agent, Mastercard's fraud-analyst-support agent, Lockheed Martin's program management agent, and at least 11 other named buyers whose deployments INTELAR has reviewed through procurement-side conversations are running variants of the same three-layer architecture. The variation is in the specific technology choices for each layer and in the integration patterns with the underlying enterprise data, but the structural three-layer shape is consistent. The reference architecture for production agent memory in Q2 2026 is the hybrid architecture, and the RAG-over-vector pattern is now treated by the procurement-grade engineering teams as a legacy approach.

Pinecone Serverless versus Weaviate Cloud cost data

The vector layer cost economics matter at production scale because the volumes are now substantial. A Fortune 100 buyer running a typical second-generation agent deployment at the JPMorgan or Pfizer scale executes between 4 million and 22 million vector queries per month, depending on the agent footprint and the workflow patterns. At those volumes, the per-query economics dominate the total memory-layer cost, and the procurement teams are now scrutinising the vector vendor pricing with materially more attention than they did in 2024. Pinecone Serverless, which became generally available in early 2024 and underwent significant pricing-model evolution through 2025, is the most-deployed vector layer across the field-study buyers we have reviewed. Weaviate Cloud is the second-most-deployed, with a particular concentration in the European buyer cohort and in the open-source-preferred engineering teams. Qdrant Cloud, Chroma Cloud, and Milvus Cloud collectively occupy a smaller share of the procurement-grade deployment base.

The Pinecone Serverless pricing model in May 2026 charges $0.33 per million write requests and $0.55 per million read requests, with a storage cost of $0.33 per GB per month and a read-unit cost of $16.50 per million reads at high query volumes (above 20 million queries per month). A typical Fortune 100 deployment at 12 million queries per month, with a 4 TB vector index and a 25:75 write-to-read ratio, runs roughly $14,000 to $17,000 per month on Pinecone Serverless before the strategic discount that Pinecone offers to procurement-grade buyers (typically 18 to 28 per cent off the published pricing for committed-volume contracts). The total annual cost at that scale, post-discount, runs between $115,000 and $170,000 — a figure that has compressed by roughly 38 per cent over the past 18 months as Pinecone's serverless infrastructure has matured.

Weaviate Cloud's pricing model is structurally different. Weaviate charges by a tiered combination of vector storage, query throughput, and feature-tier (the Enterprise tier includes RBAC, multi-tenancy isolation, and advanced index types that the Standard tier does not). The equivalent 12-million-query, 4 TB deployment at the Enterprise tier runs roughly $11,500 to $15,000 per month on Weaviate Cloud, post-discount. The cost differential against Pinecone Serverless is therefore around 15 to 20 per cent in Weaviate's favour at the procurement-grade volume tier. Weaviate's advantage on cost is partly offset by Pinecone's more mature operational tooling and by Pinecone's larger deployment base, which carries procurement-side credibility weight for the more risk-averse buyers. The procurement decision between the two vendors is therefore not a pure cost decision; it is a cost-versus-maturity decision in which different buyers weight the dimensions differently.

The cost picture changes substantially at higher query volumes. At 50 million queries per month — which is the volume the largest single deployments are now reaching — Pinecone Serverless's read-unit pricing scales linearly, producing a monthly cost of approximately $52,000 to $68,000 post-discount. Weaviate Cloud at the same volume runs approximately $41,000 to $54,000 post-discount, widening the differential to 20 to 25 per cent in Weaviate's favour. The cost difference at the largest scales is becoming a procurement-decisive factor for some buyers; we have reviewed at least three Q2 2026 procurement decisions in which the buyer transitioned from Pinecone to Weaviate explicitly on the basis of the scale-economics differential. Pinecone's response, articulated in the company's recent investor commentary, is that the scale-economics gap is closing as Pinecone's infrastructure efficiency improves and that the differential will be neutralised by Q4 2026. The procurement teams reviewing the commentary are treating it as plausible but not yet evidenced.

The deeper procurement question at the vector layer is no longer which vendor to choose; it is whether the vector layer is the right place to make the optimisation decision at all. The hybrid memory architecture has reduced the share of total memory-layer cost that the vector layer represents. In a typical hybrid deployment, the vector layer is roughly 35 to 45 per cent of the total memory-layer cost, the knowledge graph layer is roughly 30 to 40 per cent, and the short-term context layer is roughly 20 to 30 per cent. The composition has shifted from the 2024 pattern in which the vector layer was approximately 75 to 85 per cent of the total memory-layer cost. The shift means that procurement optimisation effort is now distributed across three layers rather than concentrated at the vector layer. The Pinecone-versus-Weaviate decision still matters, but it is no longer the single dominant procurement question in the agent memory category.

LangGraph state-checkpoint primitives and the runtime memory surface

The short-term context layer in the hybrid memory architecture is increasingly managed by the orchestration runtime through state-checkpoint primitives. LangGraph's checkpointer interface, which became generally available in late 2024 and has matured significantly through 2025-2026, is the most widely deployed checkpoint surface. The checkpointer allows the orchestration runtime to persist the agent's working state at defined points in the workflow, restore the state when the workflow resumes (potentially across hours, days, or weeks), and replay the state for audit and observability purposes. The checkpointer is, in operational terms, the load-bearing component for long-running agent workflows. The previous pattern of stuffing all the relevant context into the model's context window at each invocation does not scale to the second-generation workflow patterns. The checkpoint primitive does.

LangGraph's checkpoint interface supports four backend implementations in May 2026: in-memory (for development), PostgreSQL (the most common production deployment), Redis (for high-throughput, lower-durability requirements), and a beta DynamoDB backend (for AWS-native deployments). The PostgreSQL backend is the dominant production choice by deployment count, primarily because it integrates cleanly with the existing PostgreSQL infrastructure that most enterprise buyers already operate and because the durability and consistency guarantees match the requirements of long-running agent workflows. The Redis backend has emerged as a specific choice for high-throughput customer-facing agents where the lower durability guarantees are acceptable in exchange for the throughput advantages. The DynamoDB backend is in beta and is being evaluated by AWS-native deployments as a serverless alternative to the PostgreSQL backend.

The procurement-side evaluation of the LangGraph checkpoint interface against the alternative runtime checkpoint surfaces (AWS Bedrock Agents' session-state, Azure AI Foundry's conversation-state, Google Vertex Agent Builder's session-context) has been a recurring discussion in the Q2 2026 procurement memos we have reviewed. The evaluation pattern is consistent: the runtime checkpoint surface is procurement-preferred when the buyer has selected a primary runtime that provides it, because the runtime-native checkpoint surface integrates more cleanly with the runtime's observability and governance surfaces. LangGraph's checkpointer is procurement-preferred when the buyer's primary orchestration is LangGraph itself, which — as the four-Fortune-100 field study established — is a smaller share of the procurement-grade buyer base than the LangGraph deployment count would suggest. The checkpoint surface is therefore tied to the broader runtime-versus-orchestration-framework procurement decision that we have covered separately.

The checkpoint primitive design itself has become more sophisticated over the past two quarters. The Q1 2026 LangGraph release added a checkpoint compression feature that reduces the storage cost of long-running workflows by approximately 40 to 60 per cent (by storing only the deltas between checkpoints rather than the full state at each checkpoint), and the Q2 2026 release added a checkpoint replay feature that allows the workflow to be replayed from any historical checkpoint for debugging and audit purposes. The replay feature is the procurement-decisive feature for regulated-industry buyers, because it provides the auditability surface that compliance teams require for agent workflows operating in high-stakes contexts. Pfizer's clinical trial protocol agent uses the checkpoint replay feature for FDA 21 CFR Part 11 audit compliance; JPMorgan's wealth management agent uses it for the bank's internal compliance review of advisor-facing agent outputs.

The deeper architectural shift in the checkpoint category is the recognition that agent memory is not just a retrieval problem; it is a state-management problem. The 2024 pattern treated memory as a retrieval problem and built the architecture around the vector store. The 2026 pattern treats memory as a three-layer problem in which retrieval (the vector layer), relations (the knowledge graph layer), and state (the checkpoint layer) are separate concerns managed by separate components. The architectural shift has consequences for the entire agent-deployment stack: it changes the optimisation surface, it redistributes the procurement spend, and it requires the engineering teams to think about memory in structurally different ways than the 2024 deployment guides taught them. The teams that have made the shift are running the production-default architecture for the second-generation agent workflows. The teams that have not yet made the shift are running architectures that the post-mortem reports will increasingly diagnose as the root cause of operational incidents.

Three production incidents and the operational lessons

The operational lessons from the transition to hybrid memory are best illustrated by three production incidents that occurred in Q1 and Q2 2026 across the buyer cohort we have reviewed. The incidents are anonymised because the affected buyers have asked for editorial discretion, but the operational patterns are consistent enough that the lessons generalise.

The first incident, at a US financial services buyer in February 2026, involved an agent workflow that was supposed to summarise a multi-month research engagement for a wealth advisor's client review. The workflow had been operating on a RAG-over-vector architecture and had been generating summaries that the advisor team rated as adequate but not consistently useful. In February, a senior research analyst received a summary that was factually correct at the document level but that incorrectly attributed an investment thesis to a research note that had been superseded six weeks earlier by a contradictory note. The advisor relied on the incorrect attribution in a client conversation. The error was caught in a routine quality review the following week, but the incident triggered an architectural review that identified the temporal-coherence failure mode of RAG-over-vector as the root cause. The buyer transitioned to the hybrid architecture over the following 11 weeks. The lesson is that the temporal coherence failure mode produces hallucinations that are individually plausible — the model is not hallucinating in any traditional sense; it is faithfully incorporating retrieved context that is stale — and that the failure mode is invisible to the model-level evaluation suites that the engineering teams had been running.

The second incident, at a healthcare technology buyer in March 2026, involved an agent workflow that was supposed to track a patient's clinical care pathway across multiple encounters. The workflow had been operating on a RAG-over-vector architecture extended with a custom context-window-stuffing approach that the engineering team had built to handle the multi-encounter pattern. In March, the agent lost track of a patient's medication change across three encounters, treating the pre-change medication as still active in subsequent care recommendations. A clinician overrode the agent recommendation, which is the workflow design, but the override surfaced the issue to the engineering team. The root cause was the absence of explicit state-machine reasoning in the architecture. The buyer transitioned to a hybrid architecture with explicit checkpoint primitives over the following 14 weeks. The lesson is that context-window-stuffing approaches do not scale to multi-encounter workflows and that the absence of explicit state primitives produces failure modes that the engineering teams initially attribute to model hallucination but that the post-mortems consistently trace to the architecture.

The third incident, at a European retailer in April 2026, involved a customer-facing agent that was supposed to handle returns triage and replacement requests. The workflow had been operating on a RAG-over-vector architecture with a custom session-management overlay built by the retailer's engineering team. In April, a high-volume Sunday produced a cascade of incidents in which the agent lost session state mid-conversation across roughly 4,200 customer interactions over a three-hour window, requiring the customers to restart their conversations from scratch. The customer-experience impact was material; the operational impact was a several-hundred-thousand-Euro cost in customer service overhead and reputational impact. The root cause was a combination of the session-management implementation's reliance on the vector store as the de facto session-state layer and a vector store performance regression during the high-volume window. The buyer transitioned to a hybrid architecture with a dedicated checkpoint layer over the following nine weeks. The lesson is that overloading the vector layer with state-management responsibilities is a fragile architectural pattern that fails under load, and that the explicit separation of state management into the runtime checkpoint layer is the production-grade pattern.

The three incidents together illustrate the structural reasons that the hybrid memory architecture has displaced RAG-over-vector in production-grade deployments. Each incident exposed a different failure mode of the prior architecture (temporal coherence, state-machine reasoning, state-management overload), each incident triggered an architectural review at the affected buyer, and each architectural review concluded with the same structural recommendation: separate the memory into three layers, use the right tool for each layer, and let the orchestration runtime manage the composition. The recommendation is not a vendor preference; it is an architectural pattern. The implementation can vary across vendors and across buyers, but the structural shape is converging across the procurement-grade buyer base.

What to watch

The hybrid memory architecture has been the production-default pattern for less than a quarter. The Q3 2026 cycle will determine whether the pattern generalises further and what the next-generation memory primitives will look like.

• Whether the knowledge graph layer consolidates around Neo4j or whether Memgraph, TigerGraph, and the HANA Knowledge Graph capture incremental procurement share; the four-buyer pattern we reviewed has Neo4j in two deployments, Memgraph in one, and HANA Knowledge Graph in one, with the broader buyer cohort showing similar fragmentation; Q3 procurement decisions will indicate whether the category converges on a single vendor or remains fragmented along the strategic-data-platform dimension.
• Whether Pinecone closes the scale-economics gap against Weaviate in the second half of 2026; Pinecone's investor commentary has signalled that the gap will neutralise by Q4 2026, and the procurement teams running the largest deployments are tracking the actual cost trajectory month-by-month against that commitment.
• Whether the runtime-native checkpoint surfaces — Bedrock Agents session-state, Foundry conversation-state, Vertex session-context — produce the auditability features that the regulated-industry buyers require, or whether LangGraph's checkpoint replay capability remains procurement-preferred in regulated contexts; the auditability surface is the procurement-decisive feature in regulated industries and the runtime-native surfaces are currently less mature than LangGraph's on that dimension.
• Whether the hybrid memory architecture pattern produces a new procurement category — "memory orchestration" — separate from the broader orchestration runtime category; some early signals suggest that buyers are starting to articulate memory-layer governance as a distinct procurement dimension, and the vendors that can deliver an integrated three-layer memory product will be the natural beneficiaries.
• Whether the operational cost of running hybrid memory at scale produces buyer-side pressure on the model providers for context-handling improvements that reduce the need for explicit memory architecture; the alternative narrative — that frontier models with sufficiently long context windows and sufficiently good retrieval-within-context can subsume the explicit memory architecture — is being actively articulated by OpenAI and Google, and the next 18 months will determine whether the explicit-memory architecture or the long-context-model architecture becomes the dominant production pattern.

Frequently asked

What is the structural difference between the hybrid memory architecture and RAG-over-vector?

RAG-over-vector treats agent memory as a single homogeneous retrieval surface: embed a query, match against a vector index, retrieve top-k documents, concatenate into the prompt. The hybrid architecture separates memory into three layers: a knowledge graph for relational reasoning, a vector store for semantic retrieval over unstructured documents, and a short-term context layer (managed by the orchestration runtime through state-checkpoint primitives) for current task state and recent conversation history. The three layers are queried through different patterns and the orchestration runtime composes them into the agent's context for each invocation. The structural shift is the recognition that memory is not just a retrieval problem; it is a multi-dimensional problem in which retrieval, relations, and state are separate concerns.

Why did RAG-over-vector fail at scale, and what specific failure modes triggered the shift?

Three specific failure modes triggered the shift. First, relational reasoning: the vector store retrieves by semantic similarity and cannot natively traverse relational structures, which makes "find the document where person A approved decision B, then trace to decision C" queries unreliable. Second, temporal coherence: the vector store cannot distinguish between current state, historical state, and superseded state, which produces hallucinations that are individually plausible but factually wrong. Third, state-machine reasoning: the vector store cannot encode process state, which causes agents to lose track of where in a multi-step workflow the current task is. Each failure mode produced operational incidents at production-grade buyers, and the post-mortem reports consistently traced the root cause to the architecture rather than to the model.

What is the cost differential between Pinecone Serverless and Weaviate Cloud at procurement-grade scale?

At 12 million queries per month with a 4 TB index, Pinecone Serverless runs approximately $14,000 to $17,000 per month pre-discount and Weaviate Cloud runs approximately $11,500 to $15,000 per month — a 15 to 20 per cent cost differential in Weaviate's favour. At 50 million queries per month, the differential widens to 20 to 25 per cent in Weaviate's favour, with Pinecone at $52,000 to $68,000 and Weaviate at $41,000 to $54,000 monthly post-discount. The cost difference at the largest scales has been procurement-decisive in at least three Q2 2026 procurement decisions we have reviewed. Pinecone's investor commentary indicates the gap will close by Q4 2026 as infrastructure efficiency improves; the procurement teams reviewing the commentary are treating it as plausible but not yet evidenced.

How does LangGraph's checkpointer interface integrate with the broader runtime competition?

LangGraph's checkpointer supports four backend implementations (in-memory, PostgreSQL, Redis, beta DynamoDB) and is the most widely deployed checkpoint surface across LangGraph-primary deployments. For buyers whose primary runtime is LangGraph, the checkpointer is procurement-preferred. For buyers whose primary runtime is AWS Bedrock Agents, Azure AI Foundry, or Google Vertex Agent Builder, the runtime-native checkpoint surface is procurement-preferred because it integrates more cleanly with the runtime's observability and governance. The checkpoint surface decision is therefore tied to the broader runtime-versus-orchestration-framework procurement decision. LangGraph's checkpoint replay feature, added in the Q2 2026 release, is currently the most mature auditability surface and is procurement-preferred in regulated industries until the runtime-native alternatives reach parity.

What are the operational cost implications of the hybrid memory architecture compared to RAG-over-vector?

The hybrid architecture's operational cost per agent invocation runs roughly 1.3x to 1.8x the previous RAG-over-vector cost, based on the JPMorgan deployment data and similar field-study buyers. The cost increase is partially offset by a roughly 40 per cent reduction in agent-loop iterations required to complete a typical workflow, because the relational and state queries that previously required multiple retrieval-and-reasoning cycles are now resolved in a single composed query against the three memory layers. The net effective cost differential at the workflow-completion level is therefore smaller than the per-invocation differential suggests, and is procurement-acceptable for the second-generation workflows that the prior architecture could not reliably support.

Will long-context models eventually subsume the explicit memory architecture?

The question is open. OpenAI and Google have been articulating the alternative narrative — that frontier models with sufficiently long context windows (Claude Opus 4.7's 1-million-token window, Gemini 3 Pro's multi-million-token window in some configurations) and sufficiently good retrieval-within-context can subsume the explicit memory architecture. The counter-argument, articulated by the buyers running the hybrid architecture, is that the explicit memory architecture provides governance, audit, and observability features that the long-context-model approach does not, and that the cost economics of running multi-million-token contexts on every invocation are not competitive with the hybrid architecture's selective retrieval pattern. The next 18 months will determine which narrative dominates the production-deployment pattern at scale.