Most AI agents don't have a memory problem because they forget too much. They have a memory problem because they retrieve too slowly, too often, and too late — pulling stale facts back into context long after those facts stopped being true. For financial agents making decisions on portfolios, positions, and risk tolerance, that lag isn't a UX annoyance. It's a correctness problem.
In a new research paper conducted with our partners at True Trading / True Finance, INC4 proposes a fix: an interaction-native knowledge harness (InKH) that inverts how agent memory works. Instead of the agent deciding when to search its own memory, the system passively assembles the right context before the agent ever asks. In controlled benchmarking (24 seeds, 4 rounds, 80 episodes per round, 6 baselines), this approach cut latency by 82.95% (to a mean of 900 ms), cut token cost by 82.29%, and cut stale-knowledge usage by 96.58%, relative to an agent-driven "wiki-walk" memory baseline. The full paper, "Absorbing Complexity: An Interaction-Native Knowledge Harness for Financial LLM Agents," is live on arXiv, published June 1, 2026.
This blog covers why agent memory breaks at scale, what interaction-native memory means in practice, and where the numbers came from — including the caveats worth knowing before you cite them. If you're evaluating LLM memory or agentic AI memory options for a production system, the tradeoffs below apply well beyond finance.
Why Agent Memory Breaks at Scale
Agent memory breaks in three specific, compounding ways.
- Stale info accumulates. Most agent memory systems write facts once and rarely revisit them. A user's risk tolerance or stated goal from three weeks ago sits next to yesterday's update, and nothing tells the retriever which one is current. This is the core failure mode McKinsey has flagged in enterprise AI deployments: agents that are technically retrieving memory but retrieving the wrong slice of it.
- Latency grows with memory size. Agent-driven memory search — where the model itself decides to issue a retrieval call, waits on it, then reasons over the result — adds a full round trip to every turn that touches memory. As the store grows, that round trip doesn't get cheaper. This is the "wiki-walk" pattern InKH benchmarks against: the agent wanders through its own knowledge base the way a person clicks through Wikipedia links, one hop at a time.
- Retrieval cost compounds in multi-agent systems. Context engineering — deciding exactly what tokens a model sees on a given call — has become one of the fastest-growing concerns in applied AI precisely because of this. A five-agent pipeline that each pulls 100K tokens of context is five times more expensive than one that pulls 20K tokens of the right context. RAG helps with recall, but it doesn't solve when to retrieve, what's still valid, or how to keep context bounded as an agent runs for hours instead of a single session.
For a financial agent, none of this is abstract. An agent operating on stale risk parameters, or too slow to incorporate a market update before responding, isn't just inconvenient — it's the difference between a defensible recommendation and a wrong one.
Passive Injection vs. Active Retrieval
The core architectural move in InKH is to stop treating memory as something the agent has to go get, and start treating it as something the system already has ready.
Most agentic memory today is active retrieval: the agent recognizes it needs information, formulates a query, calls a retrieval tool, and waits. This puts the burden of memory management on the model itself, mid-reasoning — the agent has to correctly decide that it needs to search and what to search for, in a single inference pass.
InKH instead uses passive injection. The system treats every user message, market update, portfolio change, and tool call as part of a continuous event stream, extracting and structuring knowledge from it in the background — not on demand. When the agent needs context, a bounded working context buffer is already assembled and ready. The agent doesn't search; it reads.
That buffer sits on top of a temporal knowledge graph, the low-latency retrieval substrate — every fact carries a timestamp and a validity window, so the system can reason about when something was true, not just what was said. A parallel wiki audit surface makes the graph human-readable, so a compliance reviewer can trace why the agent believed what it believed at a given moment.
This is what "absorbing complexity" means in practice: the person doesn't need to re-explain their portfolio context every session, and the agent doesn't spend a reasoning step deciding to go look for it.
Governed Forgetting: The Strongest Result
The most consequential piece of InKH isn't retrieval speed — it's how the system decides a fact is no longer true.
Traditional agent memory rarely deletes or supersedes anything; it just keeps adding. InKH applies background extraction, maturity, decay, and write-time invalidation: when a new event contradicts or supersedes an existing fact, the system invalidates the old one at the moment of write, rather than leaving it to be filtered out (or missed) at retrieval time. Facts also decay in priority over time if they're never reconfirmed.
This is the mechanism behind our paper's largest reported effect: a 96.58% reduction in stale-knowledge usage compared to the agent-driven baseline. Instead of asking the retriever to be smart enough to skip outdated facts every time, the system removes the ambiguity earlier, at write time.
The Numbers — and Their Limits
Measured against an agent-driven wiki-walk memory baseline across 24 seeds, 4 rounds, 80 episodes per round, and 6 baselines (46,080 evaluations total):
- Latency: −82.95%, down to a mean of 900 ms
- Token cost: −82.29%
- Stale-knowledge usage: −96.58%
- Task quality: +0.108 (mean score of 0.815)
- Traceability: +0.461
These are strong, consistent effect sizes across a large evaluation set, and they point in a clear direction.
Worth noting for context: this is a research-stage benchmark, run on synthetic data rather than live trading traffic, and it's designed to isolate the architecture itself — passive injection versus agent-driven search — under controlled conditions. That's what gives us confidence the mechanism works. Validating it at full production scale is the next step. This work is happening alongside our partners at True Trading and is already shaping how their platform evolves, with InKH itself still an active R&D track.
How InKH Differs from Graphiti and Zep
InKH isn't the first system to tackle memory for AI agents with a temporal knowledge graph — Zep's open-source Graphiti engine, described in Zep's own paper, also builds a temporally-aware graph, with bi-temporal edge validity across episodic, semantic, and community layers.
The difference is where the burden of retrieval sits. Graphiti and Zep still generally operate on an active-retrieval model — the agent queries the graph when it decides it needs to. InKH's passive-injection layer sits a step earlier: it decides what belongs in the working context before the agent asks, using the event stream itself as the trigger, paired with write-time invalidation rather than retrieval-time filtering alone.
The two approaches are complementary more than competing — a temporal graph substrate like Graphiti's could plausibly sit underneath a passive-injection layer like InKH's.