AgentDeliveryBench: tasks+harness+README

README.md

@@ -0,0 +1,77 @@
+---
+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.