Jetriever scores every memory for usefulness instead of similarity — 84.8% vs 1.6% on indirect queries, and the finding-vs-ranking gap is the real lesson
A USTC retrieval service scores every stored memory for usefulness rather than textual similarity — and the finding-vs-ranking gap is the practical lesson, not the 84.8% headline.

Jetriever, a new agent-memory retrieval system from USTC, abandons similarity search: for each query it scores every stored memory for usefulness and ranks the pool by that score. On the authors' InMind benchmark of 125 indirect-query tasks, it places the decisive memory first in 84.8% of cases, versus 1.6% for BM25 and 0.0% for MiniLM.
What shipped
Jetriever is a retrieval service, not a model. For a query q and a candidate memory mᵢ, it sends only the pair (q, mᵢ) to a decision model called Jev and asks for a binary "Noul" judgment: the probability that the memory is useful for answering the query. It sorts the memory pool by that score (ties broken by memory id, since scores are rounded to two decimals) and hands the top-k memories to the answer-stage LLM, which never sees Jev's score or rationale. The paper calls this a "complete-reranking design": N independent Jev decisions for N candidates, with no approximate-nearest-neighbor index (arXiv:2611.21478).
The motivating failure mode is the "indirect query." A stored nut allergy matters when the user asks for a macaron recipe, even though the request never mentions nuts; a memory that there are lilies at home matters when the user asks about getting a cat. The connection lives in world knowledge (macarons commonly contain almond flour; lilies are toxic to cats), not in word or entity overlap.
BM25 and MiniLM rank textual correspondence, which is near zero here: on InMind's 125 tasks with user-turn indexing, BM25 ranks the gold exchange first in 2 of 125 cases (1.6%) and MiniLM in none (0.0%). Jetriever gets it first in 106 of 125 (84.8%), and within five in 115 (92.0%) (arXiv HTML).
The paper's most instructive result separates two things that similarity retrieval conflates: finding the right memory and ranking it first. On a 20-question InMind subset, Jev and a Qwen3.5 9B scorer each find 90% of gold exchanges by rank 50, while a BERT-based decision model (Laya) finds only 30%. At rank one the gap widens: Jev reaches 85%, Qwen3.5 9B only 40%. The authors' interpretation is that world knowledge gets the decisive memory into the candidate set, while calibrated scores put it at the top (alphaXiv).
Jetriever also holds up beyond implicit-association questions. On a dimension-proportional random sample of 60 MemoryAgentBench questions, its equal-weight four-dimension score is 55.4% versus 44.3% for ReFind, the authors' earlier agent-controlled BM25 system. The per-dimension split shows the source of the gain: Accurate Retrieval 65.5 vs 49.8, Test-Time Learning 40.0 vs 30.0, Long-Range Understanding 59.0 vs 55.5, Selective Forgetting 57.1 vs 41.7 (Harness Hub review).
Why it matters
The finding-versus-ranking gap is the practical lesson. A similarity pre-filter can structurally discard the decisive memory on an indirect query before any reasoning happens — the answer-stage LLM never gets to see it. Scoring every memory you actually have, rather than guessing search terms up front, sidesteps that bottleneck. The authors' framing is that effective utility retrieval needs three things at once: broad world knowledge, scores that separate decisive from merely plausible evidence, and scoring cheap enough to cover the whole pool.
The cost numbers are what make full-pool scoring plausible at real pool sizes. Jev retrieval runs about $0.00834 per InMind question (241 exchanges each) and $0.03103 per MemoryAgentBench question on average (median $0.00730; one MAB task with 42,946 candidates inflates the mean). A separate batch scored 6,446 pairs in 90.16 seconds at 100-way concurrency. These are retrieval-only charges, not answer-generation costs (arXiv, alphaXiv).
The code is released under an MIT license at github.com/imlrz/Jetriever, with a persistent SQLite store, bounded concurrency, retries, and a Dockerfile. But the system is open-source in a limited sense: it calls OpenRouter's paid Decisions API and requires an API key, because the scorer itself is not released.
Caveats
Every benchmark number above is author-reported and has not been independently reproduced. Several caveats matter before you build on this:
- The scorer is closed and paid. Jev is a proprietary TypeSafe "System One" decision model (model id
typesafe/jev-1.14) served through OpenRouter — via its Decisions API, which the Jetriever repo calls. No weights and no training-data disclosure, so benchmark overlap with its training data cannot be ruled out. The repository is MIT-licensed, but the scorer is a hosted API you cannot self-host (OpenRouter). - The headline gap is partly a benchmark artifact. InMind is the authors' own benchmark, built specifically so lexical matching fails. Independent reviewers note there is no cross-encoder or prompted pointwise LLM reranker run on the full 125 tasks, so 84.8% vs 1.6% shows an LLM judge beating lexical matching on a benchmark built to defeat it — not that Jev beats other utility scorers (Harness Hub).
- The comparisons are small and unmatched. The Qwen3.5 9B comparison is 20 of 125 questions with no confidence intervals, and Qwen scored via answer-token probabilities over 900-token windows while Jev scored complete exchanges. The MAB result is a 60-question sample with a mismatched ReFind pipeline (ReFind's answers come from an earlier run, not rerun under Jetriever's setup), and 44 of 60 questions tie.
- Scaling is the acknowledged wall. Full-pool scoring is O(N) per query. The authors state that stores with tens or hundreds of thousands of turns could become too costly and too slow, and their proposed cascade remedy for larger pools is untested. No online per-query latency was measured; the batch throughput figure is not single-query latency.
The honest takeaway is a clean, cheap-to-run pattern — score every memory for usefulness, no ANN index — that works at hundreds to thousands of candidates, with an O(N) wall ahead and headline numbers that rest on a closed scoring API nobody else can reproduce.