Coding agents do not need more context. They need remembered work.

The benchmark uses 40 SWE-bench Verified tasks and 80 total agent runs: each task runs once as a baseline and once with TraceBase attached. Across the 40 paired runs that completed cleanly, resolved rate moved from 63% to 83%, a +20 percentage-point gain. On high-confidence matches, the agent used 43% less cost and 26% fewer steps on average.

This is the benchmark TraceBase is built for: repeated engineering work where prior runs contain reusable mechanisms. The lift comes from shortening the investigation path, not from changing the model.

The benchmark follows a simple paired design: real bug-fix tasks, identical agent settings, one changed variable. Instead of asking an LLM judge whether a patch looks good, the submitted patch is graded against the task's test oracle in an isolated container.

TraceBase improved the resolved count by 8 tasks with 0 regressions. The larger effect shows up in the trajectories: on matches where retrieval had enough confidence to inject, agents reached the patch faster and spent less time re-reading files or revisiting known dead ends.

Most repeated-agent waste is not raw model weakness. It is missing local knowledge: which attempted fix failed, which file actually owned the bug, which verification command exposed the failure, and which compact patch shape finally worked. TraceBase stores those facts as reusable reasoning blocks and injects them only when retrieval is confident enough to be net-positive.

The key is that TraceBase does not shove an entire prior transcript into context. It serves a short hypothesis with evidence and asks the agent to verify it against the current code. That keeps the intervention small enough to save tokens and precise enough to shorten the search.

The store is project-scoped SQLite. Retrieval starts with fingerprint and FTS5/BM25, then combines structural, Jaccard, cosine, and freshness signals. The serving layer estimates expected net value before injection, and the lifecycle loop demotes blocks whose observed helpfulness falls below the threshold.

• The benchmark measures repeated engineering work: tasks where past resolved runs can provide reusable mechanism-level memory.
• Efficiency averages are reported on high-confidence matches, where TraceBase had enough evidence to inject.
• The measured benchmark is 40 tasks / 80 agent runs. The claim is scoped to repeated engineering work.
• Memory is injected as a hypothesis. The agent still has to verify the current code before editing.
• Cost savings vary with model pricing, tool-output volume, and how repetitive the team's work actually is.

Each task was evaluated as a pair. The baseline arm ran with the standard agent stack and an empty TraceBase store. The TraceBase arm ran with the same model settings, tool budget, timeout, and containerized test environment, with memory recall enabled before the agent started editing.

That keeps the comparison clean: TraceBase does not receive the answer key, does not change the model, and does not alter the grading harness. It changes only what the agent remembers before it starts the next run.