ToolACE-8B - AI Language Models Tool

Overview

ToolACE-8B is an 8-billion-parameter language model fine-tuned from Meta's Llama 3.1 8B Instruct family to specialize in function calling and tool usage workflows. It was trained on the Team-ACE ToolACE dataset, which the authors describe as an automatically synthesized, agentic pipeline for generating accurate, complex, and diverse tool-learning dialogs. The pipeline curates a large API pool and applies multi-agent dialog generation plus verification to create training data tailored for function-calling behavior. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B)) The model and a subset of its data are published on Hugging Face and described in an ICLR 2025 submission (ToolACE: Winning the Points of LLM Function Calling). The paper and model card emphasize that, despite being an 8B model, ToolACE-trained checkpoints achieve top-tier results on the Berkeley Function-Calling Leaderboard (BFCL), with the authors explicitly comparing their function-calling performance to much larger models. The Hugging Face model card provides usage examples for producing structured function calls from natural-language queries. ([arxiv.org](https://arxiv.org/abs/2409.00920))

Model Statistics

• Downloads: 12,508
• Likes: 73
• Parameters: 8.0B

License: apache-2.0

Model Details

Base architecture and training: ToolACE-8B is a finetuned checkpoint of meta-llama/Llama-3.1-8B-Instruct (8B parameters) provided in BF16 format on Hugging Face. The model uses the ToolACE synthetic dataset created by the Team-ACE pipeline; that pipeline includes a self-evolution synthesis stage that curated an API pool of 26,507 diverse APIs and a dual-layer verification system (rule-based + model-based) to filter and verify dialog correctness. These design elements are described in the authors' arXiv/ICLR paper and summarized on the model card. ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B)) Function-calling behavior and interface: ToolACE-8B is intended to accept a system prompt that exposes available functions (JSON/OpenAI-style function schemas) and to return structured function-call outputs (function name plus typed parameters) or sequences of calls when needed. The Hugging Face README includes a transformers-based example using tokenizer.apply_chat_template and model.generate to produce function-call outputs. The model is not listed as deployed by an external inference provider on the Hugging Face page (weights are hosted but hosted inference is provider-dependent). ([huggingface.co](https://huggingface.co/Team-ACE/ToolACE-8B))

Key Features

• Finetuned from Llama-3.1-8B-Instruct for function-calling and tool use.
• Trained on ToolACE synthetic dataset generated by a multi-agent pipeline.
• Self-evolution synthesis curated an API pool of 26,507 diverse APIs.
• Dual-layer verification (rule-based + model-based) to improve data accuracy.
• Produces structured function calls (OpenAI-style JSON schemas) and multi-call chains.

Example Usage

Example (python):

from transformers import AutoTokenizer, AutoModelForCausalLM

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

# load tokenizer and model (auto device_map / dtype recommended)
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")

# system prompt should include a JSON list of available functions (see model README)
system_prompt = """You are an expert in composing functions. You are given a question and a set of possible functions. Return only the function call(s) in the required format. Here is the function list:\n{functions}\n"""

user_query = "Get me the sales growth rate and interest coverage ratio for company XYZ over the past 3 years."

# example function list (OpenAI-style JSON schema)
functions = [
    {
        "name": "sales_growth.calculate",
        "description": "Calculate a company's sales growth rate",
        "arguments": {"type": "dict", "properties": {"company": {"type": "string"}, "years": {"type": "integer"}}, "required": ["company","years"]}
    },
    {
        "name": "financial_ratios.interest_coverage",
        "description": "Calculate 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=functions)},
    {"role": "user", "content": user_query}
]

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

# Example adapted from the model README on Hugging Face. See the model page for additional usage notes and templates. (source: Hugging Face)

Benchmarks

Parameters: 8 billion (Source: https://huggingface.co/Team-ACE/ToolACE-8B)

Tensor type: BF16 (Source: https://huggingface.co/Team-ACE/ToolACE-8B)

Downloads (last month on Hugging Face): 12,508 (Source: https://huggingface.co/Team-ACE/ToolACE-8B)

License: Apache-2.0 (Source: https://huggingface.co/Team-ACE/ToolACE-8B)

BFCL (function-calling benchmark): Reported by authors as state-of-the-art for function-calling (ToolACE-trained models rival GPT-4 on BFCL) (Source: https://arxiv.org/abs/2409.00920)

Key Information

• Category: Language Models
• Type: AI Language Models Tool