AI agents are pushing storage out of its old role as the place data lands after work is done and into the middle of the runtime loop itself.
In a report published by MarsBit and sourced from the WeChat account Xinzhiyuan, the argument is straightforward: once software shifts from a single model call to a long-running system that observes, reasons, invokes tools, changes environments and preserves state, storage starts to matter in a different way. A single task may touch models, memory, vector indexes, business databases, object storage and network services, then write back tool outputs, execution traces, user preferences, temporary context and audit records. The longer an agent runs, the more its value depends on whether data can be stored safely, retrieved correctly, updated in time and reused at low cost.
That changes the position of storage in the stack. Rather than acting only as a persistence endpoint, storage begins to sit inside the cycle of perception, memory and decision-making. The report says early AI SSD designs already hint at that direction by storing models and adapters, taking over KV cache that has been pushed out of memory, shortening cold starts and expanding deployable model capacity. From there, SSDs could move into deterministic tasks performed at write time, including encryption, compression, deduplication, tagging, indexing, versioning and lifecycle governance, while also offering long-term capacity for agent memory.
None of this is presented as a clean break from the past. The report points to self-encrypting drives that already handle encryption and decryption inside the controller, computational storage standards that define functions such as compression, encryption, regex filtering and erasure coding on the storage side, and products like Samsung SmartSSD that moved database scans and video processing closer to the drive. What changes in the agent era is how those capabilities are recombined around agent identity, context, memory, tool traces and token cost.
In that framework, the market may end up talking about secure SSDs, compressed SSDs, retrieval SSDs, memory SSDs or context SSDs. But the report suggests those may not emerge as sharply separated hardware categories. A more likely outcome is a programmable functional SSD that still looks like standard storage at the base layer while allowing upper software layers to discover and invoke capabilities based on use case.
NVMe is already moving in that direction, according to the report, through command sets such as Computational Programs and Subsystem Local Memory, which create a standardized path for discovering, configuring and executing device-side programs. The harder question is not whether a processor can be placed inside a drive. It is who defines data semantics, where functional boundaries sit and how end-to-end outcomes are measured.
Agents produce a continuously written data chain, not a single call
Traditional chatbots mostly preserve conversation history. Agents generate a much more complex data graph.
They may need to keep observation results, tool outputs, plans and reflections, intermediate task state, user profiles, environment snapshots, retrieved evidence and execution logs. On the model side, they can also produce KV cache, prefix cache, adapters, expert weights and checkpoints. Those objects do not share the same update frequency, reuse scope or security level, but together they determine whether the next round of reasoning can continue without rebuilding state.
The report also argues that agent memory should not be treated as a matter of dumping every past conversation into a vector database. It cites recent research that breaks agent memory into four modules: representation and storage, information extraction, retrieval and routing, and maintenance. That research finds no single architecture that dominates across all workloads. It also points to Mem0, which emphasizes turning raw conversation into more compact, reusable long-term memory in order to reduce input token load and retrieval overhead in extended sessions.
That puts a new requirement on storage. It must preserve not only content, but also the rules by which content is organized, updated and forgotten. In the report’s framing, a successful write is no longer enough. A memory object should carry fields such as user or agent identity, tenant, source, time, version, permissions, confidence, retention period and deletability. Model context may also need to bind to model version, tokenizer, positional encoding and adapter. Without clear namespaces and lifecycle definitions, later compression, indexing, caching and sharing can easily break semantic boundaries.
In that chain, the proper role of a functional SSD is not to decide whether a piece of experience deserves to be remembered. That remains the job of the agent and the runtime. The SSD’s role begins after the runtime has already supplied object definitions and policy. At that point the device can perform deterministic work near the medium, choosing keys by tenant, placing data by lifecycle, compressing and deduplicating eligible objects, maintaining index pages and metadata, prioritizing readback for objects about to be used in inference, and surfacing tail latency, write amplification and media health back to upper layers.
The report’s central conclusion is that the SSD upgrade path for the agent era is not a matter of simply adding more compute into the drive. It is a matter of combining standard block devices, discoverable near-data functions, object semantics and lifecycle governance. Functions closest to the medium should remain deterministic, auditable and isolated. Decisions closest to the model should stay in the runtime.
Automatic encryption already exists, but policy is becoming agent-aware
The report is careful not to treat automatic encryption on write as a futuristic idea. Self-encrypting drives already use dedicated hardware in the controller to encrypt writes, decrypt reads and apply key management and policy controls for data-at-rest protection.
What changes for agent systems is granularity. Instead of operating only at the full-drive or namespace level, encryption policy may need to follow the user, the agent, the task and the object. Personal memory and application cache on the same edge device should not cross privilege boundaries. Shared context in a multi-tenant cloud agent system also needs clear rules on what can be reused and what must remain confined to a single authorization domain.
The report notes that NVMe has already introduced finer-grained mechanisms, including host-managed keys and Key Per I/O, which creates a basis for attaching different security context to each I/O. From there, a security-oriented SSD could combine provenance, timestamps, access records, integrity checks and trusted deletion. In that model, an agent would not only answer what it remembers. It could also answer where a memory came from, whether it has been altered, who accessed it and when it must be deleted. For finance, healthcare, enterprise knowledge bases and personal AI, the report says the evidence chain may matter as much as retrieval speed.
Encryption also changes execution order for other near-data functions. Because encrypted byte streams are usually hard to compress or deduplicate effectively, content reduction typically has to happen before encryption. Indexing, meanwhile, has to separate plaintext features, protected metadata and any searchable encrypted fields. The strength of a functional SSD, then, is not just the number of features it exposes. It is the ability to organize compression, indexing, encryption, persistence and deletion into a verifiable pipeline without turning any stage into a wider attack surface.
Compression, indexing and memory maintenance could be the next SSD functions
Compression is described as one of the easiest features to close into a business case.
Agents repeatedly write text, JSON, logs, vectors, checkpoints and multimedia intermediates, and much of that data contains structural repetition. If compression happens before data crosses the network or reaches NAND, it can reduce transmission, physical writes and capacity consumption. That can also lower energy use and flash wear. But the report does not frame compression as a free win. Compression ratio, added latency, CPU savings and write amplification have to be evaluated together. For already quantized or highly compressed model weights, the upside may be limited.
Indexing has a more direct relationship with agents because memory only matters if it can be recalled correctly. The report highlights KIOXIA AiSAQ, which places vectors and index structures on SSD and uses SSD-friendly clustering and graph search to lower DRAM requirements, with demonstrations of vector retrieval at the scale of billions on a single server. Even so, the report stresses that AiSAQ is first a software technique that uses SSD as the primary index carrier. It does not imply that ordinary SSDs can automatically generate embeddings or understand semantics. A more plausible industry path is one where GPUs, NPUs or CPUs produce representations, while SSDs and near-data programs organize the index, filter candidates and return a smaller result set.
Memory maintenance is harder still. Long-term agent memory can involve insertion, merging, conflict, revision, downranking, expiration and forgetting. The same fact may simultaneously exist as a raw record, a summary, a vector and a knowledge-graph entry. In the report’s view, a future memory SSD could support atomic updates, logs, TTL, hot-cold placement and secure deletion across those versions. What it should not do is decide truth from similarity alone. Memory quality still depends on upper-layer extraction, routing, conflict resolution and evaluation.
From a product standpoint, none of this means every drive has to run a complex model. Compression, encryption, hashing, filtering, index-page maintenance and object lifecycle management fit deterministic hardware blocks or lightweight programs. Embedding generation, reranking, summarization and memory merging are more likely to remain on the host or a dedicated accelerator. The point of a functional SSD is to connect those two categories of work through a unified object ID and observable interfaces so that less data has to move around.
On the edge, SSDs could become the long-term state layer for personal agents
The report sees a clear edge-device role for functional SSDs. Personal agents constantly touch documents, photos, email, schedules, application state, browsing history and sensor data. Unified memory is suitable for the current working set, but SSDs can hold larger local model libraries, adapters, vector indexes, personal memory and tool traces. As long as they remain compatible with standard NVMe form factors, those devices can still be installed as ordinary system drives in AI PCs and workstations, with security, indexing and context features gradually enabled through drivers, runtime software and firmware.
The user-facing value proposition is not that a hard drive can think. It is that local AI can remember for longer, keep working under weak connectivity and reduce the amount of raw data and input tokens sent to the cloud. A meeting agent could keep audio, summaries and task state. A coding agent could maintain repository indexes and change history. A home agent could share authorized photos, documents and device state across devices. The SSD keeps those states close to the device, and a router can then decide whether processing should stay local or move to the cloud based on quality, privacy, power and network conditions.
The report also extends the idea from a single drive to a small storage node. AI PCs, home servers or edge boxes in shops could provide local model images, personal memory, vector databases and encrypted archives for phones, tablets, robots and cameras, avoiding duplicated copies of the same data on every device. In that scenario, the business model could stretch beyond simple capacity upgrades into AI PC premiums, local agent subscriptions, model and skill package management, and private AI nodes for homes and small businesses.
Still, local storage does not equal privacy by default. If applications can read memory without restriction, if indexes cannot delete old versions, or if keys become detached from device identity, more functionality can simply create a larger attack surface. The report says edge functional SSDs must treat application isolation, user consent, retention windows, verifiable deletion and key revocation after device loss as product capabilities rather than marketing language.
In the cloud, SSDs move from devices to agent storage nodes
Cloud-side agent systems have a larger state footprint and a stronger need for sharing. A complex request can trigger repeated model calls, tool execution, memory access and network transfers. Multi-agent collaboration adds shared plans, messages, evidence and execution logs. In that environment, node-local SSDs may store models, checkpoints and high-frequency indexes, rack- or POD-level flash tiers may absorb KV, prefixes, adapters and shared memory reused across GPUs, and general object storage can continue to hold colder data and long-lived sources of fact.
The report points to two systems already moving in that direction. Mooncake organizes CPU, DRAM, SSD and RDMA/NIC into a distributed KV cache pool and lets the scheduler choose request paths according to cache location and TTFT and TBT targets. NVIDIA CMX builds a POD-level flash context tier for KV cache across HBM, host memory and general shared storage, placing shared storage nodes directly in the inference data path. The report does not attribute end-to-end gains to any single SSD. Its point is narrower and more important: storage nodes are beginning to participate in token production.
A next-generation agent storage node, in this view, could expose context, memory and governance at once. It might maintain shared prefix and KV directories, warm models and adapters, store vector and graph indexes, compress and encrypt data by tenant, record tool calls and chains of evidence, and export hit rate, P99 latency, write amplification, power use and media health to the scheduler. Customers would then be buying more than capacity or bandwidth. They would be buying GPU utilization, SLO goodput, Token/, Token/W, QPS/ and audit response speed.
That shift also changes monetization. A single drive can still be sold on capacity, endurance and performance. A storage node could instead combine multiple drives, a control plane, runtime licensing, long-term support and SLA commitments into a broader revenue package. Beyond that, services could emerge that bill by effective context capacity, number of memory objects, retrieval throughput or effective tokens. Once a functional SSD starts taking responsibility for end-to-end results, the report says, its value boundary expands from semiconductor device to data infrastructure.
HBM, HBF, DRAM and SSDs are being re-tiered, not replaced
The report explicitly rejects the idea that agent-driven storage restructuring means SSDs replace memory.
It cites SK hynix’s tiered memory thinking presented at FMS 2026, which links HBM, DRAM, NAND/HBF and SSD by speed, capacity and cost, with the aim of reducing data movement. That matches the way agent systems naturally split data: some must be used for the current token, some for the next few milliseconds, some may be reused across sessions and some belongs in long-term archive.
HBM remains the layer closest to GPU computation, carrying active weights, activations, hot KV and operator intermediates, with Token/s, bandwidth and compute utilization as the key metrics. The report argues that long context and multi-model coordination in agent systems raise HBM demand rather than weaken HBM’s role. The constraints are capacity cost and supply, which is why systems need cheaper lower tiers for data that does not need to be accessed immediately and accurate prewarming before reuse.
HBF, or High Bandwidth Flash, is presented as a rapidly forming tier since 2025. The report cites the first open specifications disclosed by SK hynix and Sandisk in August 2026, covering capacities up to 512 GB, bandwidth tiers of about 0.4 TB/s to 3.0 TB/s and UCIe connectivity to processors. HBF uses NAND to provide more capacity than HBM and targets read-heavy large inference working sets between HBM and SSD. But the report is cautious: early standards and published specifications do not amount to broad production performance, nor do they erase NAND’s limits in latency, write endurance and mutable-state access.
It also cites the H3 research direction, which proposes a clearer split by placing read-only data in HBF and keeping other data in HBM for hybrid inference. For agent workloads, that would make HBF a better fit for model weights, MoE experts and other read-dominant large working sets, while frequently updated KV, activations and runtime state remain a better match for HBM or DRAM. If HBF matures, it may reduce some demand to add GPUs or HBM purely for capacity. More likely, the report says, it will complement rather than replace those layers.
DRAM and CXL occupy the middle ground for mutable state and shared capacity. Host KV, hot index sets, prefetch buffers and agent runtime state need lower latency and frequent updates. CXL expansion, pooling and sharing can reduce isolated memory pools and make capacity more flexible across hosts. The report notes that SK hynix also showed CXL pooled memory and DRAM-SSD hybrid designs for KV sharing, prediction and prefetch at FMS 2026, but it frames those as demonstrations that still need broader validation.
Functional SSDs, by contrast, are positioned for larger, more durable and more governance-heavy warm and cool objects: models, adapters, KV and prefixes, vector indexes, agent memory, logs and checkpoints. Compared with HBF, SSDs sit farther from compute, but they bring standard form factors, a mature ecosystem and stronger capacity-cost economics, and they fit node-level sharing more naturally. Future competition, the report argues, will revolve less around raw media bandwidth and more around which layer can deliver the right object within the right time window while taking responsibility for effective tokens, retrieval throughput and data governance.
AI SSDs are the first industrial samples of the functional SSD thesis
The report divides current AI SSD efforts into two broad entry points.
One is the AI workload-optimized enterprise SSD, built around low latency, high IOPS, sustained bandwidth, endurance and capacity density to serve as the media base for model caches, checkpoints and vector indexes. It names Yingren’s Dongting N3X and Huawei OceanDisk LC 560 as examples. Their first job, the report says, is to make sure AI data can be stored reliably, written continuously and recalled in time. Being sold for AI does not mean they automatically understand agent memory, indexing semantics or context.
The other entry point is more active participation in the inference path. Here, SSDs are no longer waiting for generic block requests from the operating system. Through middleware, runtime integration or storage-side processing, they begin to recognize AI objects such as model weights, experts, KV cache and prefetch windows. Phison, Longsys and the Yinpu-Maxio collaboration are presented as three representative organizational approaches in that direction.
Phison’s aiDAPTIV follows what the report calls a mature SSD capability plus middleware plus toolchain model. aiDAPTIVLink manages memory between GPU VRAM and flash, slicing model weights at runtime, keeping active weights in VRAM and offloading inactive weights to aiDAPTIVCache SSDs. It can also preserve evicted KV cache so that context does not have to be recomputed after eviction. The commercial value in that route is packaging SSD hardware, software licenses, deployment tools and system support into a deliverable system. Customers can expand usable model and context capacity on workstations or local servers without redesigning compute silicon. The technical center of gravity remains compatibility with existing GPU and AI software ecosystems, using mature controllers, firmware, endurance design and platform partnerships to make flash a stable capacity tier beyond VRAM.
Longsys’s SPU plus iSA approach is described as closer to a storage execution layer plus software decision layer. On-device SPU handles lossless compression, HLC advanced caching and scheduling across different NAND media, while iSA makes decisions around MoE expert offload, KV cache lifecycle and Device Smart Prefetch, turning AI workload features into actions for prefetch, refill, compression and hot-cold migration. In that framing, the aim is not just to place more data on SSD, but to reduce DRAM usage, improve effective capacity and align storage-side processing with the pace of edge inference. The report treats this as evidence that when stronger execution capability appears near the controller, SSDs can evolve from block devices into near-data processing nodes for compression, caching and object scheduling.
The Yinpu-Maxio route is different again, described as a jointly defined compute-storage path. Yinpu starts from model structure, runtime, operating system, CPU/GPU/DRAM coordination and full-system reference design to observe expert activation, KV lifecycle, data precision and compute windows. Maxio maps those requirements to SSD controllers, firmware, cache partitions, queues, NAND adaptation and production systems. That allows product definition to work backward from token latency, model capacity and whole-system SLO to decide when data should enter SSD, at what granularity it should be stored, how it should be prefetched and which operations belong near the controller. Compared with the first two routes, the report says, that cross-domain method requires deeper system coordination, but may also be better positioned to identify new data-path problems and shape new device interfaces as model architectures and inference infrastructure keep changing.
Those three routes are not treated as mutually exclusive. Phison’s strength lies in quickly packaging capabilities into deployable systems through mature controllers, SSD products and software tools. Longsys is pushing more processing and scheduling toward the storage side through SPU and iSA. Yinpu and Maxio are working backward from the boundary between compute semantics and storage execution. Taken together, the report says, they show that the core innovation in AI SSDs has shifted from giving AI a faster drive to redistributing responsibilities across runtime, memory hierarchy, controller and flash. That is why the report sees AI SSDs as the first industrial samples of a broader functional SSD category: once software can tell a device about object type, priority, lifecycle and deadline, the foundation exists for more deterministic functions to move into storage.
From there, each route could extend into the next generation. Following the Phison path, vendors could add tenant- or agent-scoped encryption, compression, indexing and memory-service modules to SSD-plus-middleware bundles, lowering deployment friction through software compatibility and delivery tooling. Following the Longsys path, compression, hot-cold scheduling, index scans or data compaction could be handled by storage processing units under the policy of a higher-level scheduler. Following the Yinpu-Maxio path, vendors could begin with runtime requirements around long-term memory, permissions, TTL, retrieval SLO and token cost, then co-define controller commands, object metadata, firmware queues and media layout.
The report places particular weight on this cross-disciplinary angle. In the agent era, many storage functions are no longer just in-drive algorithms. Encryption has to reflect permission boundaries among agents, users and tasks. Compression has to know when data will be reused in computation. Indexing has to work with embedding systems, retrievers and model routers. Agent memory includes writes, merges, forgetting, versions and evidence chains. Looking only from the medium side risks collapsing the issue into bandwidth, capacity or an isolated operator. Looking only from the model side can ignore FTL behavior, write amplification, tail latency, power-loss protection and mass-production constraints. That is why the report argues that joint compute-storage development could become a differentiated route for functional SSDs, AI storage nodes and agent data infrastructure more broadly.
It closes this section with a warning against overextending the concept. Automatic compression does not mean every dataset yields the same space savings. On-drive indexes do not mean SSDs understand semantics. Agent memory does not mean moving an entire vector database into firmware. Every claimed feature should be proved by end-to-end metrics, including compression ratio and added latency, recall and QPS/, P99 and SLO, write amplification and endurance, key isolation and deletion verification, and ultimately Token/ and Token/W.
Three industry paths may unfold at the same time
The report ends by outlining three directions that could advance in parallel.
The first is the functionalization of SSDs. General-purpose drives will continue to exist, but capabilities such as security, compression, retrieval, memory and context will enter products through fixed functions, downloadable programs or software-defined configuration. The market may not need five separate SSD categories. It may need a discoverable, composable and isolatable framework that different consumer, enterprise and cloud products can implement in different combinations.
The second is the nodalization of storage. A single drive handles local capacity and near-data processing. An AI storage node combines multiple drives, networking, object catalogs, keys, indexes, context services and observability, then takes responsibility for end-to-end SLOs. Edge nodes would serve individuals and fleets of devices. Cloud nodes would serve GPU clusters and multi-agent systems. The unit of competition would expand from each drive to how many effective tokens and retrieval requests a site, rack or POD can deliver.
The third is the recomposition of the memory hierarchy. HBM continues to pursue maximum bandwidth. HBF uses NAND to try to provide larger read-heavy capacity near the package. DRAM and CXL take mutable state, expansion and pooling. Functional SSDs provide persistent objects and near-data services. Shared storage keeps global cold fact sources. The most valuable system capability, the report argues, will be the ability for routers and runtimes to see compute, data location, permissions, deadlines and media state at the same time and coordinate across layers.
That would also redraw industry barriers. Media vendors control capacity, bandwidth and energy efficiency. Controller and firmware companies determine whether functions can be deployed stably. Runtime and agent platforms control object semantics and scheduling. OEMs, cloud providers and system integrators determine how those functions turn into products. The companies that can cross those boundaries, establish standard interfaces and prove customer outcomes through token economics, the report says, will have the best shot at moving SSDs from simple data containers to a foundational data layer for the agent era.
Storage becomes part of agent capability
The report’s closing point is that AI agents expand the value of storage from preserving the past to supporting the next action.
Models need weights. Inference needs context. Agents need long-term memory and credible evidence. Enterprises also need security, compliance, auditability and cost control. The closer encryption, compression, indexing, memory maintenance and context services move toward the data, the more they can reduce movement, recomputation and DRAM pressure. But they also require clearer boundaries around permission, semantics and responsibility.
On that basis, the report treats AI SSDs as a starting point rather than the endpoint. The market could see more SSDs built around specific functions, or it could converge on unified programmable functional SSDs and agent storage nodes. At the same time, HBM, HBF, DRAM, CXL and SSDs are unlikely to evolve along a simple replacement chain. Their roles are more likely to be reassigned according to heat, mutability, sharing scope and access horizon. The larger opportunity, in the report’s view, lies in turning the strengths of each medium into lower token cost, greater agent continuity and a more trustworthy data lifecycle.
The article was published by MarsBit and credited to the WeChat account Xinzhiyuan, with ASI启示录 listed as author and 所罗门 as editor.