Ollama Tool-Calling Models: Full List + Best Picks (2026)

As of September 22, 2026, 94 models in the Ollama library carry the tools capability tag. 80 of them have downloadable weights you can ollama pull; the other 14 are cloud-only. The complete list is below, alphabetical, with every size and the exact pull tag, each checked against the model's tags page on ollama.com. After the list: which ones to actually use, the published benchmark numbers that exist, the VRAM arithmetic, and the failure modes that break agent loops.

If you only want a recommendation: qwen3 (0.6b to 235b) is the safe default for a general-purpose local agent, llama3.1:8b is the most-pulled tool-capable model in the library, llama3-groq-tool-use:8b holds the highest published BFCL score of any small self-hosted finetune, and functiongemma:270m is the smallest model on the list that was trained specifically for function calling.

How does Ollama mark a model as supporting tool calling?

Ollama's library shows a tools badge on models whose chat template can accept a tools array on /api/chat and return a structured tool_calls object instead of free text — the flow documented at docs.ollama.com/capabilities/tool-calling. You can filter the library for exactly these models at ollama.com/search?c=tools, and for a model already on your machine, the /api/show endpoint returns a capabilities array that lists tools when it is supported:

curl -s http://localhost:11434/api/show -d '{"model": "qwen3:8b"}' | grep -A3 capabilities

Passing a tools array to a model without the tag does not error — the model just answers in prose, which is the single most common "my agent is broken" report.

Quick picks: which Ollama tool-calling model should you use?

Full list: every Ollama model with the tools tag (80 local, alphabetical)

Sizes are the size tags shown on the model's library page; the pull tag is the smallest size that exists on the tags page (swap the size for any other listed). "thinking" and "vision" mean the model also carries those capability tags. Verified September 22, 2026.

A few notes on reading the table. Models with no size tag (the GLM, Laguna and Qwen3-Coder-Next entries) publish only quantisation tags, so the row lists those instead and the pull tag is :latest. gemma4 also lists an audio tag on its library page that is not a size. Cloud-only models that also carry the tools badge are in the next table; they run on Ollama's servers, not your GPU.

Cloud-only models with the tools tag (14)

These appear in the same tools filter but have no local weights — their only tags are cloud variants, so they need an Ollama account and an internet connection.

What makes a model good at tool calling?

Tool calling (also called function calling) is when you hand the model a list of available functions — each with a name, description, and a JSON schema for its arguments — and the model decides which to call and fills in the arguments. Ollama exposes this through the tools array on its /api/chat endpoint, and the model is expected to return a structured tool_calls object rather than free text.

Four things separate a good tool-calling model from a frustrating one:

1. Valid-JSON rate — does it return arguments that actually parse, with no trailing commas, no markdown fences, no commentary mixed in?
2. Argument accuracy — does it map your prompt to the right tool and fill the right fields (correct types, no hallucinated params)?
3. Parallel tool calls — when a request needs two lookups at once, can it emit multiple calls in a single turn instead of one-at-a-time?
4. Knowing when NOT to call — does it answer directly when no tool is needed, instead of forcing an irrelevant call?

You can check any of these yourself in about a minute. Define two tools, pass them to Ollama's tools API, and read what comes back. Here is the minimal harness — swap the model name for any pull tag from the list above:

import ollama

tools = [
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get the current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {
          "city": {"type": "string", "description": "City name"},
          "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "convert_currency",
      "description": "Convert an amount between two currencies",
      "parameters": {
        "type": "object",
        "properties": {
          "amount": {"type": "number"},
          "from": {"type": "string"},
          "to": {"type": "string"}
        },
        "required": ["amount", "from", "to"]
      }
    }
  }
]

resp = ollama.chat(
  model="qwen3:8b",
  messages=[{"role": "user",
             "content": "Weather in Tokyo in celsius, and convert 50 USD to JPY"}],
  tools=tools,
)
print(resp["message"]["tool_calls"])

A strong model returns two tool_calls from that one prompt — get_weather(city="Tokyo", unit="celsius") and convert_currency(amount=50, from="USD", to="JPY") — with clean JSON and no extra text. A weak model returns one call, forgets the unit, or wraps the JSON in a code fence that breaks the parser. For the full setup walkthrough, see our Ollama tool calling guide.

Which Ollama model has the best published tool-calling score?

The only self-hostable models on the list with a single vendor-published Berkeley Function Calling Leaderboard (BFCL) figure are the two Groq finetunes. Their Ollama library page states: Llama-3-Groq-70B-Tool-Use: 90.76% overall accuracy (#1 on BFCL at the time of publishing - July 2024) and Llama-3-Groq-8B-Tool-Use: 89.06% overall accuracy (#3 on BFCL at the time of publishing - July 2024). The leaderboard itself is maintained by the Gorilla project at UC Berkeley and has moved on considerably since July 2024, so treat those as "highest number published for an Ollama model", not "best model today".

The two Llama-3-Groq-Tool-Use models still hold the cleanest published BFCL numbers of any easily self-hosted option because Groq fine-tuned them, with Glaive, for this one job. They are based on Llama 3 (mid-2024), so they are not the newest brains, but for pure schema-following they are hard to beat. Qwen3 is the model most people should reach for today: tool calling is baked into its chat template, it runs through Ollama's tools API without hacks, and it is generations newer than the 2024 finetunes. Command-R earns its spot because Cohere trained it for genuine multi-step tool use and grounded RAG, with 35B weights and a 128K context.

You can run the Groq 8B locally with the tag verified above:

ollama pull llama3-groq-tool-use:8b
ollama run llama3-groq-tool-use:8b

The trade-off is age. If your agent only needs to translate a request into the right function call against a fixed toolset, that does not matter and the Groq 8B is an excellent, lean choice (4.7 GB download, 8K context per its library page). If your agent also has to reason hard between steps, a newer model like Qwen3 will feel smarter even if it has no headline BFCL number. We cover the 8B in depth on our Llama 3 Groq 8B model page.

Best small model for tool calling (single GPU / 8GB-16GB)

Not everyone has a 70B-capable box. If you are on a single consumer GPU, these small entries from the list stand out:

• llama3-groq-tool-use:8b — the highest published BFCL score in the small class at 89.06%. It fits comfortably in ~6-8 GB of VRAM at a 4-bit quant and is purpose-built for clean tool calls. This is the safe default if tool reliability is the only thing you care about.
• qwen3:8b (or qwen3:4b) — a better all-rounder. Native tool template, optional thinking mode, and a long context, so it both calls tools correctly and reasons well between calls. Pick this if your agent does more than dumb function dispatch. See our companion build-a-local-AI-agent walkthrough for how it slots into an agent loop.
• mistral:v0.3 (7B) — native function calling and one of the lightest footprints here, ideal for resource-constrained or edge setups. It is less specialized than the Groq finetune, so expect to validate its JSON a bit more carefully.
• functiongemma:270m, smollm2:135m/360m, granite4:350m — sub-1B models with the tools tag. FunctionGemma is the only one of the three trained explicitly for function calling; the others are general small models whose template happens to support tools, so test them on your own schema before trusting them.

For sizing any of these against your card, run the numbers through our VRAM calculator first.

A note on Qwen2.5, Gemma 4 and FunctionGemma

Three clarifications, because the naming trips people up:

• Qwen2.5-7B still works fine for tool calling and remains a solid, lighter alternative if you have not moved to Qwen3 — its instruct models support the same tools-array flow (every size from 0.5b to 72b carries the tag). Details are on our Qwen2.5 7B model page.
• Gemma 4 is in the Ollama library and does carry the tools tag — in e2b, e4b, 12b, 26b and 31b sizes, alongside vision and thinking. Earlier versions of this page said no such model existed; that was true when it was written and is no longer true.
• FunctionGemma is separate: per its library page it is "a specialized version of Google's Gemma 3 270M model fine-tuned explicitly for function calling". At 270M parameters it is a dispatcher, not a reasoner — useful when you have a fixed, small toolset and want the cheapest possible model to route calls.

How fast are tool-calling models, and what VRAM do they need?

You can work both numbers out before downloading anything. Token generation is memory-bandwidth bound — the GPU reads every weight once per token — so two bits of arithmetic cover it:

VRAM for weights (GB) at Q4_K_M  ~=  0.6 x (parameters in billions)
throughput ceiling (tok/s)        =  memory bandwidth (GB/s) / weights (GB)

The second line is an arithmetic upper bound, not a prediction. Attention, sampling, prompt processing and framework overhead all cost time, and the gap is widest on small models where fixed per-token costs dominate. What the bound is good for is sizing and sanity-checking: any tokens-per-second claim above the ceiling is wrong, whoever published it.

Worked below against 936 GB/s — the RTX 3090's published memory bandwidth, per the TechPowerUp GPU database. Substitute your own card's figure and the whole column rescales linearly.

Two practical consequences. First, tool calls are short outputs — a few dozen JSON tokens — so anything in this table returns a call quickly once the model is resident; latency is dominated by prompt processing and your own tool execution, not by generation. Second, the moment any layer spills to system RAM the ceiling drops by roughly an order of magnitude, because DDR bandwidth is a fraction of GDDR6X. Keep the whole model on the GPU. The 70B needs 48 GB, which in practice means a pair of cards — see the Ollama multi-GPU setup guide for how that split actually behaves.

Common tool-calling failure modes (and how to fix them)

Even the best model misbehaves eventually. These are the failure modes that break an agent loop, and what to do about each:

• JSON wrapped in a markdown fence. The model returns a fenced JSON code block (a triple-backtick json block) instead of a clean tool_calls object, and your parser chokes. Fix: use a model with the tools tag (Qwen3, Groq Tool-Use) so Ollama parses it into tool_calls for you, rather than asking a non-tool model to "respond in JSON."
• Hallucinated or renamed arguments. The model invents a field that is not in your schema, or renames city to location. Fix: write tight, unambiguous parameter descriptions, mark fields required, and validate the returned args against your schema before executing — never trust them blind.
• One call when you needed two (no parallel calls). Weaker models answer only the first half of a compound request. Fix: prefer models that explicitly support parallel tool calls (Firefunction-v2, Qwen3, the Groq finetunes), or split the request into separate turns.
• Calling a tool when none was needed. The model forces an irrelevant function call on a plain question. Fix: add a clear "answer directly if no tool applies" instruction and choose a model trained to abstain — the Groq Tool-Use finetunes were specifically tuned to decide whether to call.
• Wrong types (string where a number belongs). "amount": "50" instead of 50. Fix: coerce/validate types on your side; do not assume the model respects "type": "number".
• The model has no tools tag at all. Ollama accepts the request and the model answers in prose. Fix: check /api/show for tools in capabilities, or pick from the list above.

For end-to-end agent patterns that handle these gracefully, see our local AI agents guide.

Key Takeaways

1. 94 Ollama library models carry the tools tag as of September 22, 2026 — 80 with local weights, 14 cloud-only. The full list above is the answer to "which Ollama models support tool calling"; every pull tag was checked against the tags page.
2. Qwen3 is the best modern general-purpose pick — native tool template, works directly through Ollama's tools API, and sizes from 0.6b to 235b; Qwen3.6 and Qwen3.8 are the newest members for 24-32 GB cards.
3. Llama-3-Groq-Tool-Use holds the highest published BFCL number for an Ollama model (90.76% for 70B, 89.06% for 8B, July 2024) — the cleanest function-calling finetunes you can self-host, if 2024-era reasoning is acceptable.
4. For a single GPU, pick llama3-groq-tool-use:8b for pure tool reliability or qwen3:8b for reasoning-plus-tools — both fit ~8-12 GB at 4-bit.
5. Gemma 4 is in the library with the tools tag; FunctionGemma is a 270M Gemma 3 finetune built only for function calling.
6. The real metric is valid-JSON rate and argument accuracy, not chat quality. Always validate returned arguments against your schema before executing them.

Next Steps

• New to the mechanics? Start with the hands-on Ollama tool calling guide.
• Building an agent? Follow the build a local AI agent walkthrough and the broader local AI agents guide, or compare agent-oriented picks in best Ollama models for AI agents.
• Choosing the small-GPU model? Compare the Llama 3 Groq 8B and Qwen2.5 7B model pages.
• Not sure a model fits your card? Size any quant with the VRAM calculator before downloading the weights.