LFM2.5-230M-tools

Merged BF16 weights of the LoRA tool-calling fine-tune of LiquidAI/LFM2.5-230M-Base, trained so the model emits tool calls for agentic workflows in the LFM2.5 wire format.

This is the smallest model in the family line, and the one whose tool calls are not OpenAI-shaped. Read the Tool-call format section before using it in a runtime that expects tool_calls in a JSON envelope.

Base model

This model was fine-tuned from:

LiquidAI/LFM2.5-230M-Base

Tool-call format

The chat template is the model's contract, and it is not the OpenAI one. A call renders as a bracketed list between two markers:

<|tool_call_start|>[search_files(path="src/", query="load"), read_file(path="src/app.py")]<|tool_call_end|>

• Argument values render in a Python-like form: strings single-quoted, mappings as JSON.
• A tool's arguments must be a mapping, not a JSON-encoded string; the template calls items() on them.
• The assistant span is the trainable one, and the schema list is rendered into the system turn rather than into a separate tool block.

Anything that parses this output has to know the format. A scorer that looks for an OpenAI tool_calls array will report no call on every row, which reads like a model that never learned to call tools. This model's own evaluation declares the format and parses it, so its numbers are measured against what the model actually emits.

Training

Supervised fine-tuning with LoRA, run with NeMo-RL, assistant-turn-masked cross-entropy over the tool-calling logs.

• LoRA: dim 32, alpha 32, dropout 0.05, target modules *.proj, *.w1, *.w2, *.w3 (the attention and feed-forward blocks)
• Max sequence length: 4096
• Precision: bfloat16
• Optimizer: AdamW, lr 5e-5, weight decay 0.01
• Schedule: 15-step linear warmup, then cosine decay to 1e-6
• Global batch size: 64 (micro batch 2)
• Training steps: 336 (validation every 84)
• Loss masked to assistant turns via the chat template's generation keyword

Dataset

Training used the sft_tools split of the r0b0tlab/qwen3.8-max-glm5.2-kimi-k3-distillation dataset (OpenAI messages format; assistant turns carry tool_calls). The rows are the same corpus the Qwen tool-callers trained on, rendered through this family's template.

Intended use

• Structured tool / function calling in a very small footprint (230M parameters)
• Agent-style multi-step interactions where the runtime understands the LFM2.5 format
• On-device and edge deployment

It is not intended to be a general-purpose assistant, and it is not a drop-in for a runtime that assumes the OpenAI tool-call envelope.

Sibling artifacts

• GGUF quantizations: iromu/LFM2.5-230M-tools-GGUF
• NVFP4 (vLLM): iromu/LFM2.5-230M-tools-NVFP4

Usage

Load the merged BF16 model with transformers:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "iromu/LFM2.5-230M-tools", torch_dtype="bfloat16", device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("iromu/LFM2.5-230M-tools")

Render a prompt with tools and decode greedily:

prompt = tokenizer.apply_chat_template(
    messages, tools=tools, add_generation_prompt=True, tokenize=False
)

Validation

The base row was scored at a 384-token generation cap, under the declared tool-call grammar, on the 274-row split (272 gradable), through the same scorer and decoding path the fine-tune row will use. The base model produced no parseable tool call on any of the 272 gradable rows, so a delta against it is the fine-tune's absolute number rather than a gain over something the base could already do.

The fine-tune row was scored under the same cap, grammar, split, and decoding path as the base row — that is what makes the delta admissible: a comparison between two rows that differ in cap or backend measures the harness, not the weights. It emits a parseable call on 68 of the 272 gradable rows (25.0%), matches the expected tool names on 39 (14.3%), and matches exact arguments on 36 (13.2%). Against a base that emitted nothing, the +13.2pp exact-args delta is the fine-tune's absolute number, not a gain over a working baseline.

Compare this against the Qwen line only with care: these are the same 274 tasks, but this model was trained to a different wire format than every other model in this line.