If you bolt tools and memory onto an LLM to make it an 'agent,' how do you actually prove the upgrade worked?
What would a benchmark for successful LLM agent retrofitting look like?
This explores what it would take to measure whether turning an existing LLM into a working agent (by adding tools, memory, a harness, or some fine-tuning) actually worked. That means looking past whether the agent finishes a task to whether the retrofit itself is sound.
This explores how you would test whether wrapping an existing LLM in agent machinery (tools, memory, a harness, some extra training) actually turned it into a reliable agent. No paper in the collection proposes this benchmark directly. Read together, though, they describe one fairly clearly, and its main lesson is surprising: the benchmark should mostly test the scaffolding around the model, not the model. The corpus keeps finding that reliability comes from moving work out of the model and into the system around it: memory for keeping track of state, reusable skills for procedures, and protocols for structured interaction Where does agent reliability actually come from?. Converting an LLM into an action-taking system works the same way. It is a four-stage pipeline (data, action grounding, infrastructure, safety evaluation), and the surrounding system decides whether actions are grounded or made up Can you turn an LLM into an agent by just fine-tuning?.
If that's right, the first test is a controlled swap. Keep the model's weights frozen, change only the harness, and see how much performance moves. One study did this on a terminal benchmark: improving the execution system alone lifted several fixed models, and the same playbook carried over to newer models without changes Can execution harnesses lift model performance without retuning weights?. That gives you two measurable properties of a good retrofit: how much it lifts a model, and whether it transfers to other models. The reverse also matters. A harness built by one model can perform very differently when another model runs it, so a harness's quality can't be read off one downstream score Can language models build and maintain their own agent harnesses?. A retrofit benchmark should rotate which model does the executing.
Second, a single success rate isn't enough. Two agents with the same score can differ hugely in efficiency, reliability, and how ready they are to deploy, so you need to look at the path taken, how cleanly memory is kept, and what verification costs How should we measure agent system performance beyond task success?. Memory especially should be tested piece by piece (storage, extraction, retrieval, maintenance) so you can see which part failed, not just that something did How should we actually evaluate agent memory systems?. The benchmark should also check that the retrofit didn't quietly damage the original model. Plain LLM benchmarks and agent benchmarks measure the same model in two modes, and an honest assessment covers both Are LLM and agent benchmarks really measuring different things?.
Third, a retrofit should be scored over time, not at one moment. Deployed agents can improve without retraining by storing past cases in memory Can agents learn continuously from experience without updating weights?, or by pairing fast skill injection after failures with slower training during idle periods Can agents adapt without pausing service to users?. A good benchmark would track whether the agent gets better after week one, not just how it does on day one. It would also check safety under pressure: does the agent's permission policy only ever tighten, or can adversarial input widen it? One system uses a formal logic checker so that permissions can only narrow, never silently expand Can an SMT solver prevent LLM policy drift during agent execution?.
The dimension you probably weren't expecting is cost. If most agent subtasks are routine enough for small models at 10–30× lower cost Can small language models handle most agent tasks?, a successful retrofit might be one that lets a cheaper model do the job, not one that maxes out a frontier model. Training costs can count too: LLMs can stand in for search engines during agent training, which removes API spend Can LLMs replace search engines during agent training?. Put together, a retrofit benchmark scores harness lift, transfer across models, how well the path and each memory part hold up, no loss on plain LLM tasks, improvement over time, permissions that stay locked down, and cost per success. Task completion is only one input among many.
Sources 12 notes
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Converting LLMs to action-capable systems requires four distinct stages: curating action-environment-user datasets, training for action grounding, integrating agent infrastructure with memory and tools, and rigorous safety evaluation. The surrounding system and harness determine whether actions are grounded or hallucinated.
StateM improves Terminal-Bench 2.1 accuracy across multiple models by optimizing execution systems around frozen weights. The same runbook transfers to newer models without modification, achieving 95.3% on GPT-5.6 and lifting DeepSeek-V4 Flash by 5.4 points.
Research shows that LLMs vary sharply in building harnesses across domains, struggle to retain useful intermediate updates during evolution, and produce harnesses whose performance shifts dramatically with different executors—demonstrating that harness quality cannot be inferred from downstream task scores alone.
Single task-success metrics obscure how agents achieve results across memory, context, and verification layers. Research shows identical success rates can mask enormous differences in efficiency, reliability, and deployment readiness—requiring harness-level benchmarks that measure trajectory, memory hygiene, and verification costs.
Show all 12 sources
Decomposing memory into storage, extraction, retrieval, and maintenance stages exposes design trade-offs and failure modes that task-success metrics completely hide. Module-by-module evaluation across 12 systems shows which component actually failed rather than just whether the task succeeded.
DELEGATE-52 shows that LLM benchmarks and agent benchmarks test the same model under different operating conditions—completion mode versus tool-using mode—not separate artifacts. Honest evaluation requires assessing both modes to characterize actual capability.
AgentFly formalizes agent learning as a Memory-augmented MDP with three memory modules (case, subtask, tool) that enable credit assignment and policy improvement entirely through memory operations. The approach achieved 87.88% on GAIA validation without modifying LLM parameters.
MetaClaw demonstrates that deployed agents require both rapid skill injection from failures (seconds, zero downtime) and slower gradient-based optimization during idle windows (minutes to hours). The two mechanisms reinforce each other, with better policies producing more informative failures and richer skills enabling higher-reward trajectories.
Progent uses an SMT solver to verify each LLM-proposed policy update as either a safe narrowing or a risky expansion, automatically applying safe changes while blocking silent privilege escalation even when the LLM is manipulated by adversarial input.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
ZeroSearch and SSRL demonstrate that LLMs can generate relevant documents and search results from internal knowledge, with 14B simulators matching or exceeding real search engines. Curriculum degradation and test-time scaling optimize this approach for training without API costs.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents
- Towards a Science of Scaling Agent Systems
- RRSI: Regularized Recursive Self-Improvement of Agent Harnesses
- BenchShield: Formal Model-Backed Instrumentation for Reward Integrity in LLM-Agent Evaluation Infrastructure
- AgentFly: Fine-tuning LLM Agents without Fine-tuning LLMs
- Towards a Science of AI Agent Reliability
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Holistic Agent Leaderboard: The Missing Infrastructure for AI Agent Evaluation