LFM2.5-2.6B Fable-5 Coding Agent

AyoubChLin/lfm2.5-2.6b-fable5-coding-agent is a full-parameter supervised fine-tune of LiquidAI/LFM2.5-2.6B on saidutta69/fable-5-premium.

The run optimized assistant responses in multi-turn conversations, including reasoning-style text and tool-call patterns. All 2,697,198,592 parameters were trainable. This repository contains a complete BF16 model checkpoint—not a LoRA, QLoRA, PEFT adapter, or quantized-weight checkpoint. The 8-bit optimizer affected optimizer-state storage only.

Model details

Intended use

This checkpoint is intended for research and evaluation involving:

• multi-turn assistant behavior;
• code generation and explanation;
• structured tool-call generation in a controlled agent harness; and
• further evaluation or domain adaptation.

It should not be treated as production-ready based on the evidence currently available. The recorded run did not measure code correctness, tool-call validity, factuality, security, safety, bias, multilingual performance, instruction following, or agent-task completion.

Training data

The run loaded the openai_chat Parquet files explicitly so each published split was included once. It used the first 5,000 rows of the training split and the complete validation and test splits.

Only assistant tokens contributed to the loss. System, user, tool-result, and padding tokens were masked with label -100; assistant tool calls remained supervised. No row was removed by the post-tokenization assistant-label check.

Tokenized split statistics

Before truncation, the 5,000 selected training rows had the following length distribution:

Because more than half of the selected training rows exceeded the 32,000-token training cap, long conversations were frequently truncated.

Training procedure

Checkpoints were saved with save_only_model=True. They are suitable for evaluation or deployment, but they do not contain optimizer and scheduler states for an exact training resume.

Results

Training completed in 15,553.2 seconds (approximately 4 h 19 min 13 s) at 0.321 samples/second and 0.040 optimizer steps/second. The run reported approximately 2.134e18 floating-point operations.

Perplexity is calculated as exp(loss). All losses cover only the assistant tokens selected by the masking procedure, so they are not directly comparable with full-sequence language-model losses. Training loss is averaged over the optimization trajectory, whereas validation and test losses were measured after training.

The held-out test split was not used for optimization or periodic validation. No pre-fine-tuning baseline, external benchmark, confidence interval, or repeated-seed result was recorded. These results establish held-out assistant-token loss for this run; they do not by themselves demonstrate improvement over the base model or general coding-agent quality.

Qualitative observation

For one interval-merging prompt, the checkpoint produced a structured plan and emitted a native write(...) tool call without an explicit tool schema in the prompt. The generation reached the configured max_new_tokens=768 limit before completing the program, and the resulting code was not executed or scored.

This is an illustration, not an evaluation. In deployment:

1. Provide explicit tool definitions through the serving or agent layer.
2. Parse, authorize, and validate every generated tool call before execution.
3. Run generated code in a sandbox and verify it with independent tests.
4. Do not expose preserved reasoning traces when the product requires private internal reasoning.

Inference with Transformers

Install a recent Transformers release:

%pip install -q --upgrade \
    "transformers==5.15.0" \
    "accelerate>=1.10,<2" \
    "safetensors>=0.6" \
    "huggingface_hub>=0.34"

Then apply the checkpoint's native chat template:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL_ID = "AyoubChLin/lfm2.5-2.6b-fable5-coding-agent"

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype=torch.float16,          # Important: T4 uses FP16, not BF16
    device_map={"": 0},           # Keep the complete model on GPU 0
    low_cpu_mem_usage=True,
    attn_implementation="sdpa",   # No external flash-attn installation
)

model.eval()

parameter = next(model.parameters())
print("Model device:", parameter.device)
print("Model dtype:", parameter.dtype)

assert parameter.device.type == "cuda"
assert parameter.dtype == torch.float16

messages = [
    {
        "role": "system",
        "content": (
            "You are a careful coding assistant. Return complete, executable "
            "code and briefly explain how it was verified."
        ),
    },
    {
        "role": "user",
        "content": (
            "Write a Python function that merges overlapping integer intervals. "
            "Include pytest tests."
        ),
    },
]

inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
    truncation=True,
    max_length=8192,              # Safe starting point for a T4
).to("cuda:0")

prompt_length = inputs["input_ids"].shape[1]

with torch.inference_mode():
    output = model.generate(
        **inputs,
        max_new_tokens=768,
        do_sample=True,
        temperature=0.1,
        top_k=50,
        repetition_penalty=1.1,
        use_cache=True,
        pad_token_id=tokenizer.pad_token_id,
        eos_token_id=tokenizer.eos_token_id,
    )

generated_tokens = output[0, prompt_length:]

print(
    tokenizer.decode(
        generated_tokens,
        skip_special_tokens=False,
    )
)

skip_special_tokens=False preserves native reasoning and tool-call delimiters for inspection by a compatible parser. Do not send raw reasoning or unvalidated tool syntax directly to end users or executors.

Reproducibility notes

• The source run used a single NVIDIA B200 with native BF16 support.
• The model remained in BF16 and all parameters were updated; adamw_bnb_8bit reduced optimizer-state memory only.
• OpenAI-style tool-call argument strings were normalized into mappings before the native chat template was applied.
• PRESERVE_THINKING=True retained supplied thinking content.
• The variable named WARMUP_RATIO was passed to warmup_steps, not warmup_ratio; this card reports the executed configuration rather than reinterpreting it.
• The bitsandbytes runtime reported that no CUDA 12.9 binary was available and loaded its CUDA 12.8 build instead.
• The environment reported Linux kernel 4.19.0, below the Trainer warning's recommended minimum of 5.5.0.

Limitations and responsible use

• Generated code and tool calls may be incomplete, incorrect, unsafe, or incompatible with the target environment.
• Reasoning-style text may be exposed because the training data preserved it.
• The training set was a deterministic 5,000-row prefix rather than the complete published training split.
• Heavy 32K truncation may weaken behavior that depends on information appearing late in long conversations.
• Tool-call patterns were learned without complete tool schemas; applications must supply schemas and enforce permissions externally.
• The checkpoint inherits limitations from the base model and the fine-tuning dataset.

Review and comply with the licenses and terms of both the base model and the training dataset before use or redistribution. This model card does not grant additional rights.

Acknowledgements

• Base model: LiquidAI/LFM2.5-2.6B
• Training dataset: saidutta69/fable-5-premium