Agentic AI workloads demand more memory than traditional AI, especially when running locally. As models grow and agents maintain long-running state, memory becomes the primary bottleneck. This article explains how aiDAPTIV<\/a> extends effective AI memory to enable larger, more capable models to run reliably on practical systems.<\/p>\n<\/blockquote>\n <\/p>\n Persistent, tool-using AI agents are moving into real workflows. AMD has coined a new device category for this moment, the \u201cAgent Computer.\u201d NVIDIA announced NemoClaw, an open-source security and privacy layer built on top of OpenClaw that adds policy-based guardrails for enterprise deployments. Everyone is talking about what agents can do. Far less attention is going to what it takes to run capable agentic AI well on local systems.<\/p>\n That matters because agentic workloads raise the bar. They do more than answer a single prompt. They plan, use tools, keep state over time, and work across multiple steps. For that kind of work, model quality matters more, which often pushes developers toward larger, more capable models.<\/p>\n <\/p>\n The case for running AI<\/a> agents locally is straightforward. Local deployment keeps sensitive data on-device, avoids cloud inference costs that scale with usage, reduces latency for interactive workloads, and gives developers more control over the model and its behavior. For enterprises handling proprietary data, and for OEMs building always-on agent experiences, local inference<\/a> is often a requirement, not just a preference.<\/p>\n The problem is that many developers still rely on the cloud for capable agentic AI for a simple reason: stronger models are easier to run there.<\/p>\n For many local systems, the bottleneck is not compute alone. It is memory. GPU VRAM is limited. System DRAM<\/a> or unified memory is limited. When memory runs short, local deployments often fall back to smaller models, tighter limits, or more aggressive quantization.<\/p>\n Those tradeoffs may help a model fit, but they can also reduce reliability in multi-step reasoning, tool use, and longer-running tasks. In other words, local agentic AI often settles for smaller models not because smaller models are ideal, but because memory limits force the compromise.<\/p>\n <\/p>\n An AI agent is more than a chatbot. Instead of answering one prompt and stopping, it can keep state over time, use tools, check external systems, and take actions on your behalf.<\/p>\n That changes the memory problem.<\/p>\n Most chatbot interactions are relatively short-lived compared with agent workflows. Agents are different. They maintain persistent session state, manage long context windows, monitor changing data sources over time, and orchestrate multiple tools simultaneously. That means they often need to keep more state available for longer.<\/p>\n For developers building more complex workflows, it may not be just one agent. A coding agent tied to a repo, a research agent monitoring data sources, and a writing agent managing long-form context each bring their own session state and tools, multiplying memory demand quickly.<\/p>\n <\/p>\n A large local model at 4-bit quantization can require dozens of gigabytes just for weights. A high-end consumer GPU may have 24 GB of VRAM. The math gets difficult before you account for KV cache, runtime overhead, or agent state.<\/p>\n That is why local agentic AI often gets pushed toward smaller models. The issue is not just whether a model can launch. It is whether a more capable model can run reliably enough to support persistent, tool-using, multi-step workloads on practical client hardware.<\/p>\n Without a solution, developers and OEMs face hard tradeoffs: truncate context and lose coherence, accept latency spikes when data spills into slower tiers, or require expensive high-memory GPUs that price many users out of the market. None of these are ideal if agent PCs are supposed to reach mainstream adoption.<\/p>\n <\/p>\n <\/p>\n aiDAPTIV addresses these challenges by extending effective AI memory across GPU memory, system DRAM, and flash memory<\/a>, creating a memory hierarchy that helps larger models run on more practical systems without requiring developers to manage each tier manually.<\/p>\n <\/p>\n Hot data stays in VRAM. Warm data stays in DRAM, ready for fast reuse. Colder data can tier to an aiDAPTIV Cache Memory SSD instead of being discarded outright. This does not eliminate latency tradeoffs, but it can make larger and longer-running agent workloads practical on systems that would otherwise hit memory<\/a> limits much sooner.<\/p>\n <\/p>\n In a Mixture of Experts model<\/a>, only a subset of experts is active for each token. aiDAPTIV helps keep the active or recently used experts closer to compute, while less-active experts can tier to lower-cost memory.<\/p>\n <\/p>\n The router selects the experts needed for the current token. Active experts stay in GPU memory for immediate execution. Recently used experts can remain in system DRAM for fast reuse. Less-active experts can tier to aiDAPTIV Cache Memory instead of forcing the model down to a smaller configuration. When one of those experts is needed again, aiDAPTIV helps bring it back into a faster tier.<\/p>\n aiDAPTIV\u2019s dynamic MoE offloading integrates with llama.cpp, making this capability available through a standard inference API endpoint.<\/p>\n At GTC 2026<\/a>, Phison demonstrated a simple OpenClaw app on an Acer laptop with an NVIDIA\u00ae GeForce RTX\u2122 5090 GPU, 24 GB of VRAM, and 64 GB of system DRAM. With aiDAPTIV<\/a>, the system ran gpt-oss-120B locally, using MoE expert offloading to extend effective memory, at approximately 15 tokens per second. According to OpenAI, gpt-oss-120B requires a single 80 GB GPU to run natively, more than three times the VRAM available on the demo system. That is the tradeoff aiDAPTIV changes. Instead of forcing local agentic AI to settle for a smaller model, it helps larger, more capable models run on practical client hardware.<\/p>\n Note: OpenAI\u2019s model card lists 80 GB for single-GPU deployment. Demo throughput was approximately 15 tok\/s, or approximately 5\u20136 tok\/s with KV cache reuse enabled.<\/p>\n What this means for device makers<\/p>\n OEMs building agent PCs today face a difficult choice: spec a GPU with enough memory to handle larger agent workloads, which raises cost and limits the addressable market, or ship with constrained memory and accept reduced capability. Neither is an ideal product story.<\/p>\n aiDAPTIV changes that equation. A mid-range or memory-constrained client system paired with fast DRAM and aiDAPTIV Cache Memory can extend effective memory, making larger agent workloads practical without requiring much-higher-memory GPUs.<\/p>\n That matters especially in notebooks and other lower-memory client systems. As integrated GPUs and client GPUs become more capable, memory remains one of the main barriers to running serious agentic workloads locally. Intelligent memory tiering helps make longer-running, more capable agents practical on thinner, lower-cost systems that would otherwise hit those limits much sooner.<\/p>\n The shift to agentic AI exposes a practical problem underneath the excitement: stronger local agents need stronger models, and stronger models need more memory. That memory-elasticity layer remains a real gap in the local AI stack. That is the problem aiDAPTIV<\/a> is built to solve.<\/p>\n![\"\"](\"https:\/\/phisonblog.com\/wp-content\/uploads\/2026\/04\/The-AI-Memory-Wall-Why-AI-PCs-Cant-Keep-Up-banner.jpg\")
<\/a>Why local agentic AI matters<\/h3>\n
What makes agentic workloads harder<\/h3>\n
Local hardware hits a memory wall<\/h3>\n
![\"\"](\"https:\/\/phisonblog.com\/wp-content\/uploads\/2026\/04\/Pascari-Adaptiv-Banner-e1775768160620.png\")
<\/a>How Phison\u2019s Pascari aiDAPTIV\u2122 extends AI memory<\/h3>\n
![\"\"](\"https:\/\/phisonblog.com\/wp-content\/uploads\/2026\/04\/How-Phisons-Pascari-aiDAPTIV\u2122-extends-AI-memory-1-1-scaled.png\")
<\/p>\nHow aiDAPTIV runs larger MoE models locally<\/h3>\n
![\"\"](\"https:\/\/phisonblog.com\/wp-content\/uploads\/2026\/04\/How-aiDAPTIV-runs-larger-MoE-models-locally-scaled.png\")
<\/p>\n\u00a0<\/h3>\n
GTC 2026: Running a 120B model on a laptop<\/h3>\n
\u00a0<\/h3>\n
The gap aiDAPTIV fills<\/h3>\n
\u00a0<\/h3>\n
Work with Phison<\/h3>\n