Skip to content

Bitcoin accepted at checkout  |  Ships from Laval, QC, Canada  |  Expert support since 2016

Local LLM Agent-Capability: Which Open Models Reliably Drive Tools (2026)

A local LLM that writes a beautiful paragraph can still fail completely at the one thing an agent needs: reliably emitting a valid tool call, every time, in the exact shape your code expects. That’s a distinct, trained-in skill, and it’s what separates a chatbot from an agent brain. This database is the agent-capability layer on top of our local-LLM model catalog — it scores the major self-hostable families on how well they actually drive tools, measured against the benchmarks of record rather than vibes, with every number dated because this leaderboard genuinely moves month to month.

Quick answer

A local LLM that chats well can still be useless at driving an agent — reliably emitting a valid tool call is a different, trained-in skill. As of mid-2026 the open-weight tool-calling crown belongs to Qwen, which occupies roughly 10 of 13 slots on the Berkeley Function-Calling Leaderboard; for heavier agentic work (tau-bench, SWE-bench) GLM-4.5/4.6 and Kimi K2.6 lead, all under permissive licenses. The distinction that decides whether a model works as an agent brain is whether it has a NATIVE trained-in tool template (Qwen, Mistral, Llama, Hermes, Granite, GLM, Phi-4-mini all do) or needs grammar-constrained decoding bolted on (Gemma 2/3, base Phi-4 and DeepSeek-R1 do not) — and reliability falls off a cliff below about 4 billion parameters. This database scores each family on both, with every benchmark number dated because this leaderboard moves monthly.

Smallest safe local agent driver: the ~4B trio — Phi-4-mini (MIT, native tool tokens, the safest single pick), Qwen3-4B-2507, Gemma 4 E4B — always paired with grammar-constrained decoding. Bigger single-GPU workhorse: Devstral Small 2 (24B, coding) or Qwen3 14B/32B. Heavyweight commercial-clean agentic: GLM-4.5-Air (MIT). Avoid Cohere Command for production (entire lineup is non-commercial). And re-check every score after August 2026 — this list rots fast.

🔴 Freshness: every score is dated (2026-07-18) — this leaderboard moves monthly. BFCL v3 and v4 are different suites and NOT cross-comparable. Re-verify at gorilla.cs.berkeley.edu before trusting any figure after ~August 2026.

Model familyTool tierNative format?Benchmark (dated)Smallest reliableLicense
Qwen3.5 (open sizes)Alibaba Qwen · MoE 397B-A17B / 122B-A10B / 35B-A3B; dense 27B/9B/4B/2B excellent native BFCL-v4 (2026-07-18): 397B-A17B 0.729, 27B 0.685, 9B 0.661, 4B 0.503, 2B 0.436 — highest-scoring OPEN family 9B usable, 27B recommended; 4B marginal, <=2B unreliable permissiveApache-2.0
Best for: Top open-weight general tool-caller; 27B dense = single-GPU sweet spot. Qwen owns ~10 of 13 BFCL-v4 slots. Score collapse 9B(0.661)->4B(0.503) marks the practical agent floor. The board-topping Qwen3.7 Max is proprietary API.
Qwen3-Next-80B-A3B / Qwen3-235B-A22BAlibaba Qwen · 80B-A3B (3B active); 235B-A22B (2507) excellent native BFCL-v3 (2026-07-18): Qwen3-Next-80B-A3B-Thinking 0.720 (top open), 235B-Thinking-2507 0.719 80B-A3B (3B active) best perf/cost; 235B for max accuracy permissiveApache-2.0
Best for: Highest-accuracy open general tool-caller; 3B-active MoE keeps inference cheap. For Thinking models avoid ReAct/stopword tool templates (emits stopwords mid-thought, breaks parsing — Qwen docs).
Qwen3-Coder-Next (80B-A3B) / Qwen3-Coder (480B)Alibaba Qwen · 480B-A35B; Coder-Next 80B-A3B excellent (coding agents) native Coder-Next 80B-A3B >70% SWE-bench Verified w/ SWE-Agent (2026-03-03); 480B ~Claude-Sonnet-4-class 80B-A3B (3B active) delivers flagship agentics at low cost permissiveApache-2.0
Best for: Long-horizon coding agents with heavy tool use + failure recovery. 3B-active MoE is the standout cost/performance pick for local coding agents; trained via large-scale agentic RL.
Qwen3 dense (4B–32B)Alibaba Qwen · 0.6B/1.7B/4B/8B/14B/32B (dual-mode) good (14B/32B), fair (8B), poor (<=1.7B) native tau2-Telecom: 14B 32%, 4B-2507 27% (ToolMind, arXiv 2511.15718). Param count a WEAK predictor <8B (non-monotonic) 4B usable (esp 2507), 8B+ recommended; 1.7B unreliable permissiveApache-2.0
Best for: Edge/on-device tool agents — 4B-2507 is the smallest genuinely reliable Qwen tool-caller. Non-thinking mode + xgrammar is the standard recipe for 4B/8B agents. Always grammar-constrain below 8B.
GLM-4.5 / GLM-4.5-AirZhipu / Z.ai · 355B-A32B; Air 106B-A12B excellent (ARC: agentic/reasoning/coding) native tau-bench 70.1%, BFCL-v3 ~76.7% best-overall-among-baselines, SWE-bench Verified 64.2% (arXiv 2508.06471, Jul/Aug 2025). Beats Gemini 2.5 Pro on tau-bench Air (106B/12B active) — multi-GPU or heavily-quantized big single GPU; NOT a laptop model permissiveMIT
Best for: Open-weight coding/agentic workhorse for multi-step tool + browser + code-exec loops. THE 2026 standout for open agentic tool use — near-frontier tau-bench/BFCL with an MIT license. Only cost is VRAM.
GLM-4.6Z.ai · ~357B MoE, 200K ctx excellent native near Claude-Sonnet-class on coding/agentic (Z.ai release 2025-09-30); exact tau/BFCL deltas over 4.5 unverified large MoE only (use 4.5-Air if smaller needed) permissiveMIT
Best for: Long-context coding + search/browser agent, self-hosted, commercial-OK. Coding/agent-focused refresh of 4.5. Later GLM-4.7/GLM-5 references exist in 2026 sources but are only partly verified.
Kimi K2 / K2.6Moonshot AI · 1T-A32B MoE excellent native tau2-Telecom 96% (K2.6); SOTA on Humanity's Last Exam / BrowseComp with tools (Moonshot 2026). Stable across 200-300 sequential calls 1T MoE (32B active) — hosting is the barrier, needs a serious multi-GPU rig permissiveModified MIT
Best for: Long-horizon agentic coding + deep tool loops (200-300 calls) where you can host a 1T MoE. K2.6 released 2026-04-20. Frontier-class open agentic model, but the 1T footprint is out of reach for typical self-hosters despite the permissive license.
DeepSeek-V3.2DeepSeek-AI · 671B-A37B MoE excellent native tau2-bench: Airline 63.8, Retail 81.1, Telecom 96.2 (arXiv 2512.02556, Dec 2025) 671B only — server-class multi-GPU permissiveMIT (verify per download)
Best for: Reasoning-heavy multi-turn agents interleaving thinking + tool calls. Best-documented DeepSeek agent numbers. Watch inference-engine compat for thinking-mode tool calls — template changed vs V3.1.
Devstral Small 2 / Devstral 2Mistral (w/ All Hands AI) · Small 2 24B; Devstral 2 123B excellent (coding agents) native SWE-bench Verified: Devstral 2 (123B) 72.2%, Small 2 (24B) 68.0% (2025-12-09) — among best open-weight SWE-bench Small 2 (24B) runs on one RTX 4090 / 32GB Mac, still 68% SWE-bench permissiveApache-2.0 (Small; verify 123B card)
Best for: THE open-weight choice for self-hosted coding agents (repo-level bug-fix / PR automation). 256K context; ships open-source Mistral Vibe CLI. Strongest agentic-coding story in the Mistral camp.
Mistral Small 3.x / 4 (24B)Mistral AI · 24B (3.1/3.2 add vision) good (3.2 improved FC) native no clean public BFCL v3/v4 entry (2026-07-18); vendor 'improved FC' notes only — unverified 24B is the family floor, reliable for tools permissiveApache-2.0
Best for: Best single-GPU (24B) open agent worker: native format + permissive license. Mistral 3 (Large 3 + Ministral 3) all Apache-2.0 too — replaces the non-commercial Large 2 for blocked self-hosters.
Hermes 4 (14B / 70B / 405B)Nous Research · 14B (Qwen3 base); 70B/405B (Llama-3.1 base) good (14B) -> excellent (70B/405B) native Hermes 4 released 2025-08-26, SOTA-among-open on Nous suite; no canonical dated BFCL/tau row (unverified) 14B — Apache-2.0, no MAU cap (Qwen3 base) permissive (14B) / restricted (70B+)MIXED: 14B Apache-2.0; 70B/405B Llama Community License
Best for: Neutral-aligned, low-refusal local tool agent; the 14B is the best small commercial pick here. The Hermes tool format is now a de-facto standard reused across Qwen/others. Hermes 4-14B / Apache-2.0 is a standout.
IBM Granite 4.xIBM · 4.1 up to ~30B, 512K ctx; 4.0 H-Small 32B-A9B, H-Tiny 7B, Micro 3B, Nano 350M/1B good (8B) -> excellent (Small/30B) native BFCL-v3 (2026): 4.1 8B 68.27%, 4.1 30B 73.68% (ahead of Gemma-3-27B-class) ~7-8B reliably; 3B Micro for edge; 350M-1B Nano for constrained edge tool calling permissiveApache-2.0 (signed, ISO-42001 certified)
Best for: Memory-efficient, commercially-clean enterprise/edge agent (Mamba hybrid = low KV-cache for long tool loops). The safest COMMERCIAL self-host pick: permissive license + efficiency + dated BFCL numbers.
Llama 3.3 70BMeta · 70B only good native BFCL v2 tool-use 77.3% (2024-12-06; top open at the time). Llama no longer on the LIVE BFCL v3 top table 70B (only size) — ~405B-class tool use at 70B footprint restrictedLlama 3.3 Community License (>700M MAU cap)
Best for: Best-value self-hosted Llama agent brain. The practical Llama pick for agents in 2026, but its benchmark lead has been overtaken by Qwen/GLM. Meta's 2026 frontier work went CLOSED-weight.
Phi-4-miniMicrosoft · 3.8B (+ multimodal ~5.6B) good (for its size) native BFCL v4 low-to-mid 80s (ertas third-party, May 2026) — no official Berkeley row IT IS the small option (3.8B), fits an 8GB GPU permissiveMIT
Best for: On-device MIT-licensed tool agent — the safest single small pick. Real native tool template + MIT (fewer license strings). Note the LARGER base Phi-4 (14B) LACKS this template — only the mini has it.
Gemma 4 (E4B / 26B-A4B / 31B)Google · E2B/E4B; 26B-A4B MoE; 31B dense (2026-03-31) good native BFCL v4: 26B-A4B ~89% non-live, E4B mid-to-high 80s — both THIRD-PARTY (unsloth/ertas), not official Berkeley E4B (4B effective) smallest reliable general tool-caller permissive (unverified)Apache-2.0 claimed on release page — UNVERIFIED (conflicts with Gemma's historical custom license; confirm on the weight download)
Best for: On-device/edge agent needing native structured tool calls with a small footprint. Resolves Gemma's no-native-format history (Gemma 2/3 had NO tool template — grammar-constrain only). Verify the Apache-2.0 claim — material if true.
Gemma 2 / 3Google · Gemma 2: 2B/9B/27B; Gemma 3: 1B/4B/12B/27B + 3n poor (2/3) — no native tool support grammar-only none official 27B, and only with heavy prompt scaffolding restrictedGemma Terms of Use (custom, non-OSI)
Best for: Avoid for tools; chat/summarization with grammar-constrained JSON if forced. THE baseline 'no native tool template' case — every tool call is prompt-engineered + parsed, YOU supply the structure via grammar. Google shipped FunctionGemma-270M and Gemma 4 tokens specifically to fix this.
Command-R / R+ / R7B / Command ACohere · R 35B; R+ 104B; R7B 7B; Command A 111B good (R/R7B) -> excellent (R+/Command A) native R+ beat GPT-4 Turbo on ToolTalk(Hard) + topped BFCL single-turn FC (Cohere eval 2024, ~84 BFCL secondary — exact unverified) R7B (7B) smallest agent-capable, single 12-16GB GPU; good tool-ABSTENTION non-commercialCC-BY-NC-4.0 + AUP — NON-COMMERCIAL across the ENTIRE open lineup
Best for: On-prem RAG agent with grounded citations + multi-step/parallel tools (research/non-commercial only). 🔴 Capability-strong RAG+tool combo, but the non-commercial license disqualifies most production self-hosting. R7B's know-when-NOT-to-call is a rare, valuable property.
DeepSeek-R1 + distillsDeepSeek-AI · R1 671B; distills 1.5B-70B (Qwen/Llama bases) poor -> fair (community templates) partial none reliable — R1 targeted reasoning (AIME/MATH), not function-calling 14B distill smallest marginally usable for tools; <8B weak permissiveMIT (R1 + all six distills)
Best for: Reasoning/planning LAYER feeding a separate tool-executor — not a direct tool-caller. Tool calling was a known R1 weak point, fixed in V3.1/V3.2 not R1. <think> tags break naive tool-call parsers. Same caveat applies to base Phi-4 and Phi-4-reasoning.

The smallest reliable driver. The smallest genuinely reliable, commercially-clean local agent driver in 2026 is the ~3.8-4B on-device trio: Phi-4-mini (3.8B, MIT, native tool tokens), Qwen3-4B-Instruct-2507 (Apache-2.0, native template, strong with grammar constraints), and Gemma 4 E4B (native tokens). Phi-4-mini is the safest single pick — real trained-in tool tokens + MIT + fits an 8GB GPU. Pair ANY of them with grammar-constrained decoding and per-task eval; below ~4B, drop to a fine-tuned specialist (FunctionGemma-270M) rather than expect general tool-calling. For a bigger single-GPU workhorse, Devstral Small 2 (24B) or Qwen3 14B/32B is the reliability step-up.

Native format vs grammar-constrained decoding. Grammar-constrained decoding restricts the allowed tokens at each step so the output physically cannot leave your schema — llama.cpp GBNF, Outlines (Pydantic), and XGrammar (now the DEFAULT backend in vLLM and SGLang, ~100x faster than earlier libs; exposed via guided_json/guided_grammar/guided_regex) let even models with NO native tool template (Gemma 2/3, base Phi-4, DeepSeek-R1) emit valid tool calls and kill the validate-retry loop. Key distinction: a NATIVE trained-in format makes the model reliably CHOOSE the right call; grammar-constraining only guarantees the SHAPE is valid — you want both, and on weak/small models grammar is what makes them usable at all.

Open data (CC BY 4.0): CSV · JSON · API: /wp-json/dc/v1/agent-capability

Native format beats grammar — but you want both

The single distinction that decides whether a model works as an agent is whether it has a native, trained-in tool template. Qwen (Hermes-style), Mistral ([TOOL_CALLS]), Llama (<|python_tag|>), Hermes (which actually invented the <tool_call> format everyone else now borrows), Granite, GLM and Phi-4-mini all have one — the model has been taught to choose the right call and format it correctly. Gemma 2 and 3, base Phi-4, and DeepSeek-R1 do not; with them, every tool call is prompt-engineered and parsed by hand. That’s where grammar-constrained decoding comes in: tools like llama.cpp’s GBNF, Outlines, and XGrammar (now the default backend in both vLLM and SGLang) restrict the model’s allowed tokens so the output physically cannot leave your JSON schema. The key nuance: a native format makes the model pick the right call; grammar only guarantees the call is shaped validly. You want both — and on small or weak models, grammar-constraining is what makes them usable at all.

Who’s actually winning, and the size cliff

As of mid-2026 the open-weight tool-calling crown belongs to Qwen, which holds roughly ten of the thirteen slots on the Berkeley Function-Calling Leaderboard; for the heavier agentic benchmarks (tau-bench, SWE-bench) GLM-4.5/4.6 and Kimi K2.6 lead, all under permissive MIT-class licenses. Llama and Mistral, despite strong 2024–25 numbers, have slipped off the live top table. And there’s a hard floor: reliability falls off a cliff below about four billion parameters — Qwen3.5 drops from 0.661 at 9B to 0.503 at 4B to 0.436 at 2B — and parameter count is a poor predictor under 8B, with genuinely non-monotonic quirks. The smallest safe local agent driver is the ~4B on-device trio (Phi-4-mini being the safest single pick: MIT-licensed, native tool tokens, fits an 8 GB GPU), always paired with grammar constraints; go smaller and you should switch to a fine-tuned single-purpose specialist rather than expect general tool-calling.

One caution the table makes explicit: Cohere’s entire Command lineup is capable but non-commercially licensed, a production dead end despite excellent RAG-plus-tools behavior. For the models themselves — VRAM, quantization, general specs — see the local LLM model database; size the hardware with the VRAM calculator; check what phones home with the telemetry audit; and for the speech layer of an agent, the voice-AI database. Start at the Local LLM Canada hub. And to see how these tool-calling scores sit alongside coding, reasoning, vision and our own first-party hardware-design results, zoom out to the LLM Benchmark Hub. And re-check every score here after August 2026 — in this corner of the stack, a dataset without dates is a dataset lying to you.