Jev-Mem Splits Agent Memory Control From LLM Reasoning
Long-running AI agents need memory. They need to remember what happened earlier in a conversation, what tools they have used, what facts they have established, and what remains unresolved. Most existing agent memory systems, however, rely on the same autoregressive language model that generates responses to also control how memories are organized and retrieved. That means expensive LLM generation sits on the critical path of every memory operation, slowing everything down.
Researchers at the University of Texas at Dallas have built a system that separates these concerns. Jev-Mem, developed by Dongming Jiang, Yi Li, and Bingzhe Li, hands memory organization and retrieval control to a lightweight controller and calls the LLM only when the agent needs to do actual reasoning.
The Three-Plane Architecture
Jev-Mem draws its design from cognitive science. The model distinguishes between System-One thinking, which is fast and automatic, and System-Two thinking, which is slower and deliberative. The architecture mirrors this division across three distinct planes.
The System-One control plane handles all fast decisions. During memory construction, it assigns memory types and defines relational organization. During retrieval, it routes queries, allocates retrieval budgets, performs graph traversal, scores candidate memories, and decides when to stop searching adaptively. None of these operations require LLM generation.
The structured multi-relational memory plane stores the actual memories in an organized format with explicit relationships between them. This structure lets the controller navigate connections efficiently without asking an LLM to reason about what is related to what.
The System-Two reasoning plane runs only for complex reasoning and answer synthesis. This is where the LLM is actually invoked, and it is invoked only when genuinely needed. By keeping LLM calls off the memory management path, the system avoids the latency penalty of autoregressive generation for operations that do not require it.
Performance Results
On the LoCoMo long-term conversation benchmark, Jev-Mem scored 0.777 with an LLM judge, representing an 11.0 percent relative improvement over the strongest baseline system. The controller handles query routing and retrieval so efficiently that average query latency dropped to 0.93 seconds, a 36.7 percent reduction compared to competing approaches.
Memory construction is where the speedup is most dramatic. Building the memory structure takes 158 seconds, which is 6.6 times faster than the fastest competing memory system. Since memory construction happens for every new agent session, this saving compounds across every interaction the agent performs.
Why This Matters for Agent Design
The pattern Jev-Mem exploits is universal across agent architectures. Every time an agent needs to decide what to remember, what to retrieve, and which memories are relevant, the typical approach routes that decision through an LLM. This works but is expensive and slow. A lightweight controller that performs the same routing decisions without invoking a language model can do it faster and cheaper, with no loss in accuracy.
The practical implication is that agents built on Jev-Mem can handle longer conversations and more complex task sequences without the memory management overhead becoming a bottleneck. The controller keeps the memory structure clean and navigable, and the LLM steps in only when the agent needs to synthesize an answer or reason through a genuinely difficult problem.
For developers building long-horizon agents, this separation of concerns offers a way to reduce latency and cost without sacrificing the quality of the agent's memory. The controller handles the bookkeeping. The LLM handles the thinking. Each does what it is actually good at.