Datasets:
File size: 3,395 Bytes
b2d3100 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | ---
license: apache-2.0
task_categories:
- text-generation
tags:
- agent
- tool-use
- function-calling
- benchmark
- evaluation
- agentic
language:
- en
pretty_name: AgentDeliveryBench
---
# AgentDeliveryBench — does your tool-using agent actually *deliver the answer*?
A small, fast, deterministic benchmark for **multi-turn tool-using agents** that measures the two
things state-based benchmarks miss:
1. **Answer delivery** — after using tools, does the agent give a final natural-language answer that
actually *states the correct result*?
2. **Termination** — does it finish within a turn budget *without looping* (no repeated/identical
tool calls, no running to max-turns)?
## Why this exists
Popular function-calling benchmarks (e.g. BFCL `multi_turn`) score the **final backend STATE** — did
the right files/DB rows end up correct. We found this is *misleading for real agents*: a model can
**pass the benchmark while being useless** — it makes the right tool calls, leaves the correct state,
but then **loops** or ends with *"Done — I've completed that"* and **never tells the user the
answer**. We watched fine-tunes that beat the state benchmark score **0/15** on real agent tasks
(loop, never answer), while smaller untuned models that *delivered answers* scored far higher.
**AgentDeliveryBench scores what a user actually experiences:** a correct, stated answer, delivered
without flailing.
## What's in it
- **`agent_tasks.json`** — 30 verifiable tasks across 5 difficulty tiers (easy → expert), each with a
deterministic answer. Tiers: easy(3), medium(4), hard(4), really_hard(4), **expert(15)**. The
expert tier targets the agentic failure modes: error-recovery, multi-constraint search,
long-horizon dependency chains, read-modify-write loops, fidelity (big-number / exact value),
and verification.
- **`agent_eval.py`** — a faithful, lightweight agent loop over any **OpenAI-compatible**
`/v1/chat/completions` endpoint (works with Ollama, vLLM, etc.) with a real **sandboxed toolset**
(`write_file`, `read_file`, `run_python`). Model-agnostic (handles native `tool_calls` *and* raw
Hermes `<tool_call>`). Scores **success = answer_ok AND terminated**, with a per-difficulty
breakdown.
- **`generate_harvest_tasks.py`** — generates a larger TRAIN split of task variations (the 30 stay
held-out as the gate).
## Run it
```bash
# point at any OpenAI-compatible server (default: local Ollama)
AGENTEVAL_URL=http://127.0.0.1:11434/v1/chat/completions \
python agent_eval.py <model> --tasks agent_tasks.json --max-turns 10
```
## Leaderboard (30 tasks, success = correct stated answer + clean termination)
| model | overall | easy | medium | hard | really_hard | expert |
|---|---|---|---|---|---|---|
| **Qwen3.5-4B** | **0.90** | 3/3 | 4/4 | 4/4 | 4/4 | 12/15 |
| Qwen3.5-2B | 0.77 | 3/3 | 4/4 | 3/4 | 4/4 | 9/15 |
| Qwen3.5-0.8B | 0.53 | 3/3 | 2/4 | 3/4 | 3/4 | 5/15 |
| *(BFCL-tuned 3B fine-tunes)* | ~0.00 | — | — | — | — | — |
Note the punchline: models that **win state-based benchmarks (and have stronger raw reasoning)** can
score **~0 here** — they make correct tool calls but **loop and never state the answer**. Even a
**0.8B** model that *delivers* answers beats them. The discriminating axis is **termination /
answer-delivery**, not tool-call correctness.
## License
Apache-2.0.
|