A fast, tiny function-calling model fine-tuned from LiquidAI/LFM2.5-1.2B-Instruct. Built on LFM2.5's hybrid recurrent-attention architecture for significantly faster inference than transformer-only models of similar or even smaller size — fast enough to run on the CPU of a mobile phone.
No thinking trace or chain-of-thought required. As an instruct-tuned model, it produces accurate tool calls directly without verbose reasoning overhead, keeping latency low and token usage minimal.
Highlights
Blazing fast inference — hybrid recurrent-attention architecture runs faster than similarly-sized (and even smaller) pure transformer models on both GPU and CPU
No thinking trace needed — direct tool calls without chain-of-thought overhead, unlike reasoning-based models
Runs anywhere — Q4_K_M quantization fits in ~700 MB, fast enough for Android phones, Raspberry Pi, edge servers
Strong irrelevance detection (80.42%) — reliably refuses to call tools when no tool matches the query, avoiding hallucinated function calls
94.25% simple function calling — accurate single-tool selection and argument extraction
All scores from BFCL V4, Q8_0 GGUF quantization via llama-server on a single NVIDIA RTX 5090.
JSON Syntax Reliability
JSON Syntax Reliability
Model
JSON Validity
Invalid
Tool Calls*
Nexus-TinyFunction-1.2B-v2.0
99.3%
18
2458
xLAM-2 3B
99.8%
4
2485
xLAM-2 1B
99.6%
10
2480
Qwen3.5 4B
99.1%
21
2423
Qwen3.5 2B
99.0%
24
2296
Qwen3.5 0.8B
98.9%
25
2220
LFM2.5 Nova 1.2B
98.3%
23
1334
LFM2.5 Base 1.2B
96.8%
13
407
*Tool Calls = samples where the model attempted a tool call (out of 2,501 total per model). Models with fewer tool calls responded with plain text more often — the base model only attempted 407/2,501 calls.
BFCL V4 Official Leaderboard Comparison
How does a 1.2B model compare to frontier API models? We evaluated on 5 of 8 BFCL V4 non-live categories (Python Simple, Multiple, Parallel, Parallel Multiple, Irrelevance Detection). Java Simple, JavaScript Simple, and the combined Simple AST average are excluded — we did not train on or evaluate these categories.
Transparency: Official leaderboard scores use API inference at full precision. Our scores are from Q8_0 GGUF quantization via llama-server. The # rank shown is each model's official rank across all 8 non-live categories.
Faster than transformers at any size — LFM2.5's hybrid recurrent-attention architecture achieves faster inference than pure transformer models of similar size, and even outpaces many smaller transformer models. The sub-quadratic scaling on sequence length is especially beneficial for function-calling workloads where tool definitions consume significant context.
Built for edge and mobile — At 1.2B parameters, the model runs on consumer hardware, Android phones, Raspberry Pi, and edge servers. The Q4_K_M quantization fits in under 700 MB of RAM.
Instruct-tuned, not reasoning-dependent — The base model is already instruct-tuned, so function calls are produced directly without chain-of-thought or thinking traces. This keeps latency low and avoids wasting tokens on reasoning overhead.
Massive improvement over base — The base LFM2.5-1.2B-Instruct averages just 24.8% on BFCL V4 non-live categories. Our fine-tune brings that to 85.2% — a 60pp gain.
Single NVIDIA RTX 5090 (32 GB) — training, quantization, and all benchmarks
Format
ChatML with <tools> / <tool_call> XML tags
Prompt Format
This model uses ChatML format with XML-tagged tool definitions and tool calls.
Important: Do not use apply_chat_template(tools=...) — the base model's chat template formats tools differently than our fine-tune expects. Instead, include the tools directly in the system message as shown below.
System Prompt with Tools
<|im_start|>system
You are a function calling AI assistant. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions.
<tools>
[{"name": "get_weather", "description": "Get current weather for a location", "parameters": {"type": "object", "properties": {"city": {"type": "string", "description": "City name"}}, "required": ["city"]}}]
</tools><|im_end|>
Single Tool Call
<|im_start|>user
What's the weather in Tokyo?<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "get_weather", "arguments": {"city": "Tokyo"}}
</tool_call><|im_end|>
Parallel Tool Calls
When multiple tools should be called, the model outputs them as a JSON array:
<|im_start|>user
What's the weather in Tokyo and London?<|im_end|>
<|im_start|>assistant
<tool_call>
[{"name": "get_weather", "arguments": {"city": "Tokyo"}}, {"name": "get_weather", "arguments": {"city": "London"}}]
</tool_call><|im_end|>
Irrelevance (No Tool Match)
When no tool matches the user's query, the model responds in plain text without any tool call tags:
<|im_start|>user
Tell me a joke<|im_end|>
<|im_start|>assistant
Sure! Why do programmers prefer dark mode? Because light attracts bugs!<|im_end|>
How to Use
With Transformers
python
1from transformers import AutoModelForCausalLM, AutoTokenizer
2import json
34model_id ="nexus-syntegra/Nexus-TinyFunction-1.2B-v2.0"5tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)6model = AutoModelForCausalLM.from_pretrained(7 model_id, torch_dtype="bfloat16", device_map="auto", trust_remote_code=True8)910tools =[{"name":"get_weather","description":"Get weather for a city",11"parameters":{"type":"object","properties":{"city":{"type":"string"}},12"required":["city"]}}]1314system_prompt =(15"You are a function calling AI assistant. You are provided with function "16"signatures within <tools></tools> XML tags. You may call one or more functions "17"to assist with the user query. Don't make assumptions about what values to "18"plug into functions.\n\n<tools>\n"+ json.dumps(tools)+"\n</tools>"19)2021messages =[22{"role":"system","content": system_prompt},23{"role":"user","content":"What's the weather in Tokyo and London?"},24]2526input_ids = tokenizer.apply_chat_template(27 messages, add_generation_prompt=True, return_tensors="pt"28)29input_ids = input_ids.to(model.device)30output = model.generate(input_ids, max_new_tokens=256, do_sample=False)31print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=False))
1# Download the Q4_K_M quantization2huggingface-cli download nexus-syntegra/Nexus-TinyFunction-1.2B-v2.0-GGUF \3 Nexus-TinyFunction-1.2B-v2.0-q4_k_m.gguf --local-dir .45# Run server with function calling support6./llama-server \7 --model Nexus-TinyFunction-1.2B-v2.0-q4_k_m.gguf \8 --jinja \9 --ctx-size 4096\10 --port 8080
With Ollama
bash
1# Create a Modelfile2cat> Modelfile <<'EOF'
3FROM ./Nexus-TinyFunction-1.2B-v2.0-q4_k_m.gguf
4PARAMETER temperature 0
5PARAMETER num_ctx 4096
6EOF78ollama create nexus-tinyfunction-1.2b-v2.0 -f Modelfile
9ollama run nexus-tinyfunction-1.2b-v2.0
Training Details
Method
QLoRA Supervised Fine-Tuning (SFT) with 3-stage curriculum learning, followed by Direct Preference Optimization (DPO). Trained using Unsloth + TRL SFTTrainer.
Training Data
~38,000 curated examples from public datasets and synthetic augmentation:
Dataset
Examples
Purpose
Public function-calling datasets
~16,500
General function calling and irrelevance detection
Single NVIDIA RTX 5090 (32 GB) — all training, quantization, and benchmarks
iMatrix-Enhanced GGUF Quantizations
These quantizations use importance matrix (iMatrix) data computed from domain-specific calibration data to improve quality at lower bit widths. The iMatrix tells the quantizer which weights are most important for the model's actual use case, resulting in better quality at the same file size compared to standard quantization.
Parallel function calling is the weakest dimension — the model sometimes drops or merges parallel calls
Argument extraction for complex nested objects and optional parameters can be imprecise
English only — trained exclusively on English data
Context length — quality may degrade with very long tool lists near the 32K limit
Not suitable for safety-critical, medical, legal, or financial applications
Fine-tuning contributions licensed under Apache 2.0; base model weights remain subject to the LFM Open License v1.0 ($10M annual revenue commercial use threshold)
1@misc{Nexus_TinyFunction_1_2B_v2_0,
2 title = {Nexus-TinyFunction-1.2B-v2.0: Function Calling Fine-Tune of LFM2.5-1.2B},
3 author = {Nexus-Syntegra},
4 year = {2026},
5 url = {https://huggingface.co/nexus-syntegra/Nexus-TinyFunction-1.2B-v2.0},
6 note = {Fine-tuned from LiquidAI/LFM2.5-1.2B-Instruct for function calling}
7}
