1 min readfrom Machine Learning

TRACE: open-source hierarchical memory for LLM agents, 82.5% on MemoryAgentBench’s EventQA using gpt-oss-20B [P]

Our take

Introducing TRACE, an innovative, open-source hierarchical memory system designed to empower LLM agents. Unlike traditional RAG approaches that rely on flat chunks, TRACE organizes conversation history into a topic tree—branches and summaries—resulting in superior performance. Benchmarked on MemoryAgentBench’s EventQA task using gpt-oss-20B, TRACE achieved an impressive 82.5% F1 score, significantly outperforming leading models like Mem0 and MemGPT. Installation is simple: `pip install trace-memory`. For a deeper dive into related advancements in AI, explore "LingBot-Vision," which demonstrates masked boundary modeling for self-supervised pre

The recent emergence of TRACE, an open-source hierarchical memory system for LLM agents, represents a significant step forward in addressing a persistent challenge in the field: effectively managing and utilizing long conversation histories. The core innovation—organizing agent conversations into a topic tree rather than relying on flat RAG (Retrieval Augmented Generation) chunks—demonstrates a clever approach to contextual understanding. This contrasts with previous methods, as seen in discussions around self-supervised pretraining techniques like those explored in LingBot-Vision: masked boundary modeling for self-supervised pretraining, where the focus is on feature extraction rather than memory organization. The impressive results—82.5% and 83.8% F1 scores on MemoryAgentBench’s EventQA task using gpt-oss-20B and gpt-oss-120B respectively—outpace existing solutions like Mem0 and MemGPT/Letta when evaluated against GPT-4o-mini, highlighting the potential of this hierarchical structure for improved accuracy and recall. It's a compelling demonstration of how architectural choices can dramatically impact agent performance.

What’s particularly noteworthy is the practical, accessible nature of this work. The author's decision to release TRACE as a PyPI package ("pip install trace-memory") lowers the barrier to entry for experimentation and integration. The transparency of sharing full JSON logs from both runs further underscores the commitment to reproducibility and allows for deeper scrutiny of the methodology. The acknowledgement of challenges encountered while attempting to integrate TRACE with other models, like Mem0 and Letta, showcases a realistic and honest assessment of the current landscape. This contrasts sharply with the sometimes-inflated claims that permeate the AI space, and echoes concerns about evolving job requirements detailed in Machine learning industry job requirements used to be myopic, but now it feels impossible, suggesting a need for more grounded and practical skillsets. The open-weights model approach, utilizing gpt-oss, further strengthens the accessibility and allows for broader experimentation outside of costly proprietary platforms.

The underlying principle of hierarchical memory—creating summaries and branches to represent conversational threads—is intuitively appealing. It mimics how humans organize information, allowing agents to quickly access relevant context without wading through an entire conversation history. This is a key advantage over flat RAG approaches, which can struggle with long and complex dialogues. While achieving accurate JSON output from open-source models remains a challenge, as noted by the author, the presented results are impressive regardless. The fact that TRACE demonstrates strong performance even with relatively smaller models (gpt-oss-20B) suggests that it could be particularly valuable for resource-constrained environments or applications where minimizing computational cost is a priority. The approach also offers an interesting parallel to the design considerations in systems like those featured in Edge AI ASL Recognition on Raspberry Pi 5 – Looking for Feedback on My System Design, which similarly prioritize efficiency and accessibility in edge computing scenarios.

Ultimately, TRACE’s success underscores the importance of revisiting fundamental architectural choices in LLM agent design. While RAG remains a vital technique, incorporating hierarchical memory structures like those implemented in TRACE presents a compelling pathway toward more robust, efficient, and contextually aware agents. As LLMs continue to grow in size and complexity, the ability to effectively manage and utilize long-term memory will become increasingly crucial. The question now is: how quickly will this approach be adopted and adapted by the broader community, and what new innovations will emerge as a direct result of this significant contribution to the field?

Built a memory system called TRACE that organizes agent conversation history into a topic tree (branches + summaries) instead of flat RAG chunks, and benchmarked it on MemoryAgentBench (ICLR 2026), specifically the EventQA accurate-retrieval task.

Its a pypi package:

pip install trace-memory

Results (F1):
• TRACE (gpt-oss-20B): 82.5%
• TRACE (gpt-oss-120B): 83.8%
• Mem0 (GPT-4o-mini, paper’s official number): 37.5%
• MemGPT/Letta (GPT-4o-mini, paper’s official number): 26.2%

Ran gpt-oss locally, so this is an open-weights model against MemGPT/Mem0 on GPT-4o-mini, not an apples-to-apples same-backbone test (I don’t have the money for open ai tokens).

I tried to get Mem0 running on gpt-oss-20B directly for fairness, but its fact-extraction step needs strict JSON output and gpt-oss’s responses didn’t parse cleanly (known issue, not gpt-oss specific. Same bug shows up with Gemini/Mistral too). Letta needs a full server setup so I skipped it.

Full JSON logs from both runs are in the repo if you want to dig into the methodology yourselves. GitHub: https://github.com/husain34/TRACE

submitted by /u/PsychologicalDot7749
[link] [comments]

Read on the original site

Open the publisher's page for the full experience

View original article