---
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.