Home › Language Models › ToolACE-8B

ToolACE-8B - AI Language Models Tool

Overview

ToolACE-8B is an 8-billion-parameter LLaMA-3.1-8B-Instruct model fine-tuned for robust function/tool calling and tool-oriented dialog generation. The model was trained on the Team-ACE ToolACE dataset and is published on the Hugging Face Hub; it is distributed in BF16 safetensors format under an Apache-2.0 license. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B)) The ToolACE project introduces an automatic agentic pipeline (ToolACE) that synthesizes a large API pool and multi-agent dialogs using a self-evolution synthesis process, and then verifies generated data with a dual-layer verification system. Models trained on that data (including ToolACE-8B) achieved state-of-the-art scores on the Berkeley Function-Calling Leaderboard (BFCL), with ToolACE-8B reporting an overall BFCL-v1 accuracy of 91.41% and a BFCL-v2 overall score of 85.77% in the authors' evaluation. ([ar5iv.org](https://ar5iv.org/pdf/2409.00920)) Because it was designed specifically for function-calling tasks, ToolACE-8B is well suited for translating natural-language requests into structured function calls (single, parallel, or dependent), handling nested parameter types, and producing concise tool-call outputs usable by tool-execution frameworks. The model and dataset (ToolACE) are available from Team-ACE on Hugging Face. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B))

Model Statistics

  • Downloads: 11,353
  • Likes: 70
  • Parameters: 8.0B

License: apache-2.0

Model Details

Architecture and base: ToolACE-8B is a fine-tuned instance of meta-llama/Meta-Llama-3.1-8B-Instruct (8B parameters). The Hub listing shows BF16 tensor-format weights packaged as safetensors; the model card and files are available on Hugging Face. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B)) Training & dataset: The model was trained with the ToolACE synthetic tool-learning pipeline. Key pipeline components described in the paper include Tool Self-evolution Synthesis (TSS) to produce a curated API pool of 26,507 APIs, Multi-Agent Interactive dialog generation (MAI), and a Dual-Layer Validation (DLV) combining rule-based checks with model-based verification to improve data accuracy. These modules are documented in the ToolACE paper. ([ar5iv.org](https://ar5iv.org/pdf/2409.00920)) Function-calling behavior: ToolACE-8B is optimized to accept a chat-style prompt plus a JSON/OpenAI-style tool list and to output structured function calls. The Hugging Face usage examples show a pattern where the model emits a pythonic list of function calls (e.g., [sales_growth.calculate(...), ...]) that can be parsed and executed by a downstream tool runner. Community tooling (for example, vLLM helper templates) also references ToolACE-8B's pythonic tool-call style. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B)) Practical notes: The model is usable with transformers' AutoTokenizer/AutoModelForCausalLM; the Hub examples use tokenizer.apply_chat_template and model.generate with device_map='auto' and torch_dtype='auto'. The repository lists newer ToolACE variants (ToolACE-2, ToolACE-2.5) indicating ongoing improvements. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B))

Key Features

  • Fine-tuned from Meta Llama-3.1-8B-Instruct; 8B parameters.
  • Optimized for function/tool calling: single, parallel, and dependent calls.
  • Trained on ToolACE pipeline with 26,507 curated APIs for broad coverage.
  • Dual-layer verification (rule-based + model-based) for higher data accuracy.
  • Outputs pythonic structured function-call lists for direct tool execution.

Example Usage

Example (python):

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_name = "Team-ACE/ToolACE-8B"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")

system_prompt = """You are an expert in composing functions. You are given a question and a set of possible functions. Based on the question, you will need to make one or more function/tool calls to achieve the purpose.
If none of the function can be used, point it out. If the given question lacks the parameters required by the function, also point it out.
You should only return the function call in tools call sections.
If you decide to invoke any of the function(s), you MUST put it in the format of [func_name1(params_name1=params_value1, params_name2=params_value2...), func_name2(params)]
"""

query = "Find the sales growth rate and interest coverage ratio for company XYZ over the last 3 years."

# Example function list (OpenAI-style JSON)
tools = [
    {
        "name": "sales_growth.calculate",
        "description": "Calculate sales growth rate given company and years",
        "arguments": {"type": "dict", "properties": {"company": {"type": "string"}, "years": {"type": "integer"}}, "required": ["company", "years"]}
    },
    {
        "name": "financial_ratios.interest_coverage",
        "description": "Compute interest coverage ratio",
        "arguments": {"type": "dict", "properties": {"company_name": {"type": "string"}, "years": {"type": "integer"}}, "required": ["company_name", "years"]}
    }
]

messages = [
    {"role": "system", "content": system_prompt.format(functions=tools)},
    {"role": "user", "content": query}
]

inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
outputs = model.generate(inputs, max_new_tokens=256, do_sample=False, eos_token_id=tokenizer.eos_token_id)
print(tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True))

# Expected (example) output:
# [sales_growth.calculate(company="XYZ", years=3), financial_ratios.interest_coverage(company_name="XYZ", years=3)]

# (See Hugging Face model card for the same usage pattern.)

Benchmarks

BFCL-v1 overall accuracy: 91.41% (Source: https://arxiv.org/abs/2409.00920)

BFCL-v2 overall score: 85.77% (Source: https://arxiv.org/abs/2409.00920)

Hugging Face downloads (last month): 11,353 (Source: https://huggingface.co/Team-ACE/ToolACE-8B)

Last Refreshed: 2026-01-16

Key Information

  • Category: Language Models
  • Type: AI Language Models Tool
Visit Official Website

Related Tools

Qwen2.5-7B

Qwen2.5-7B is a large language model designed for text generation, featuring improvements in coding, mathematics, instruction following, long text generation, and multilingual support. It supports context lengths up to 128K tokens and is intended for sophisticated NLP tasks.
DeepSeek-V3

Open‑weight flagship LLM (base and chat) with strong reasoning and tool‑use; runs with SGLang/LMDeploy/vLLM and permissive model license.
Llama 3

Llama 3 is an open access large language model (LLM) released by Meta, available in various configurations (8B and 70B parameters) with capabilities for fine-tuning and integrations into platforms like Hugging Face, Google Cloud, and Amazon SageMaker.
UNfilteredAI-1B

A large-scale text generation model designed for creative and unconstrained content production without traditional filtering.
Shuttle-3

Shuttle-3 is a state-of-the-art language model designed for high-quality text generation, particularly suited for complex chat, multilingual communication, and reasoning tasks. It is fine-tuned from the Qwen-2.5-72b-Instruct model and designed to emulate high-quality prose similar to Claude 3 models.
WizardLM

WizardLM is a state-of-the-art large language model designed for complex chat, multilingual tasks, reasoning, and agent functionalities. It features an AI-powered pipeline (Auto Evol-Instruct) that optimizes instruction datasets for improved performance across various domains and leverages Arena Learning for an expanded learning pool of challenging instruction data.