MultiverseComputingCAI/LittleLamb-ToolCalling

<div align="center">

LittleLamb 0.3B Tool-Calling

Powered by CompactifAI

  

Tiny Model · 50% Compressed · Native Tool Calling · Thinking & Non-Thinking Modes

</div>

Table of Contents

• —Highlights
• —Model Overview
• —Key Characteristics
• —Quick Start
• —What's New in LittleLamb 0.3B Tool-Calling
• —Tool Calling
• —Dual-Mode Inference (Thinking / Non-Thinking)
• —Training & Fine-Tuning
• —Architecture
• —Evaluation & Benchmarks
• —Languages
• —Intended Use
• —Safety & Limitations
• —Model Information
• —Citation

Model Overview

LittleLamb 0.3B Tool-Calling is a tool-calling–optimized variant of LittleLamb 0.3B at 290M parameters, developed based on Qwen3-0.6B by **Multiverse Computing**. Built on top of the CompactifAI-compressed LittleLamb base, this variant has been additionally fine-tuned for function calling, structured outputs, and agentic workflows. It supports thinking and non-thinking modes while adding native tool-use support in a sub-300M-parameter footprint.

Key Characteristics

Quick Start

This model can be loaded with the Transformers library. Requires transformers>=4.51.0 for Qwen3 architecture support.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "MultiverseComputingCAI/LittleLamb-ToolCalling"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto",
)

messages = [{"role": "user", "content": "Hello!"}]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True,
)
inputs = tokenizer([text], return_tensors="pt").to(model.device)
output_ids = model.generate(**inputs, max_new_tokens=256)[0]
response = tokenizer.decode(
    output_ids[len(inputs.input_ids[0]) :], skip_special_tokens=True
)
print(response)

For OpenAI-compatible serving, use a stack that supports Qwen3 reasoning and tool calling (e.g. recent vLLM or SGLang with Qwen3 parsers); see the Qwen3-0.6B model card for deployment examples.

What's New in LittleLamb 0.3B Tool-Calling

Summary

• —Tool-calling–optimized variant of LittleLamb 0.3B, fine-tuned for function calling and structured outputs.
• —Ultra-compact at 290M parameters, suitable for edge and on-device deployment with agentic capabilities.
• —Developed based on [Qwen3-0.6B](https://huggingface.co/Qwen/Qwen3-0.6B) with CompactifAI compression (~50% parameter reduction vs. base non-embedding count).

Tool Calling

LittleLamb 0.3B Tool-Calling supports native tool use and is designed for:

• —Function calling with defined schemas
• —Structured outputs
• —Agentic operations (e.g. browser tasks, code execution where supported)

The model can detect when to invoke tools, emit structured JSON tool calls, and consume tool outputs to continue generation. Tool-calling behavior follows Qwen3-style schemas.

Example Tool Call

{
  "name": "get_weather",
  "arguments": {
    "city": "Paris",
    "date": "2026-02-10"
  }
}

Dual-Mode Inference (Thinking / Non-Thinking)

LittleLamb 0.3B Tool-Calling inherits Qwen3's dual-mode capability, supporting seamless switching between thinking mode (for complex reasoning) and non-thinking mode (for efficient general-purpose dialogue).

The model generates internal reasoning in Qwen3's thinking format (see the Qwen3 chat template) before producing the final response. Use this for tasks requiring multi-step reasoning, math, or code generation.

Set enable_thinking=False for lower-latency dialogue without explicit chain-of-thought in the template. Follow the sampling parameters recommended in the Qwen3-0.6B model card for each mode.

Training & Fine-Tuning

Base Model: Qwen3-0.6B

The base model Qwen3-0.6B is a causal language model from the Qwen3 family, supporting thinking/non-thinking modes. See the Qwen3 technical report for details.

CompactifAI Compression & Tool-Calling Fine-Tuning

• —Compression: CompactifAI was applied to produce a smaller, efficient model (~0.3B parameters) while aiming to preserve reasoning capabilities.
• —Tool-calling fine-tuning: This variant includes additional fine-tuning for function calling and structured outputs on top of the compressed LittleLamb base.

Architecture

Model Specifications

Evaluation & Benchmarks

Evaluation Methodology

Benchmark scores were obtained with the following setups. Methodology varies by benchmark family.

For LittleLamb 0.3B Tool-Calling and Qwen3-0.6B (base), benchmark runs are reported under both thinking and non-thinking chat modes using the sampling settings recommended in the Qwen3-0.6B model card.

MMLU-Pro, GPQA Diamond, IFBench

• —Evaluation framework: Nemo-skills
• —Inference library: vLLM 0.18.0
• —Thinking mode (enable_thinking=True, per Qwen3-0.6B instruct): temperature = 0.6, topp = 0.95, topk = 20, min_p = 0
• —Non-thinking mode (enable_thinking=False, per Qwen3-0.6B instruct): temperature = 0.7, topp = 0.8, topk = 20, min_p = 0

BFCL v4, τ²-Bench

• —Evaluation framework: EvalScope
• —Inference library: vLLM 0.18.0
• —Thinking mode (enable_thinking=True, per Qwen3-0.6B instruct): temperature = 0.6, topp = 0.95, topk = 20, min_p = 0
• —Non-thinking mode (enable_thinking=False, per Qwen3-0.6B instruct): temperature = 0.7, topp = 0.8, topk = 20, min_p = 0
• —Results of functiongemma-270m-it for BFCL v4 were extracted from Google's model card (09/04/2026)

Quantitative Results

Reported numbers use the methodology described above.

Thinking mode

Non-thinking mode

[image]

BFCL V4 is the de facto industry standard for evaluating function-calling (tool-use) capability. It tests whether models can correctly generate structured function calls in response to user queries, across simple single-call scenarios, parallel calls, multi-turn conversations, and complex agentic workflows.

Quantitative Results (Inference Performance)

Metrics reported

• —System Output Throughput (higher is better): Mean output tokens per second across all concurrent requests over the benchmarking phase.
• —End-to-End Latency per Query (lower is better): Median end-to-end response time for each query from the time the query is sent.
• —Output Speed per Query (higher is better): Median output tokens per second after the first token is received for each query.
• —Time to first token (TTFT) (lower is better): Median
• —Estimated Peak Memory Usage (lower is better): KV cache utilization is monitored during the phase and we estimate memory usage as follows: $model\ weights{gb} + kv\ cache{usage\pct} × (nvml\used{gb} − model\ weights_{gb})$
• —Model weights (lower is better):

Performance evaluation conditions

Our performance evaluation follows the spirit of Artificial Analysis.

• —Inference library: vLLM 0.18.0
• —Monitoring libraries: GuideLLM 0.6.0, nvidia-ml-py 13.590.48
• —Hardware: 1× NVIDIA L4 GPU
• —Conditions: concurrency=16
• —Phase duration: Each phase lasts 3 minutes (excluding ramp-up and cool-down periods).
• —Workload shape: 1,000 input tokens and 1,000 output tokens per query.
• —Streaming: Benchmarking is conducted with streaming enabled.

Summary of improvements: LittleLamb shows a slight improvement in performance with respect to the original Qwen Model. This is expected as for such small models, VRAM usage is dominated by KV cache and not model weights.

[image]

Languages

• —Primary languages: English. Spanish is yet to be tested for tool-calling capabilities.

Intended Use

Recommended Use Cases

Aligned with Qwen3-0.6B use cases, with the added benefit of tool-calling capabilities in a smaller footprint suitable for edge and on-device deployment:

• —Function calling and agentic workflows in resource-constrained environments
• —On-device and edge inference where memory and compute are constrained
• —Structured output generation (JSON, schemas)
• —Reasoning tasks with configurable thinking/non-thinking modes
• —Chatbots and virtual assistants with tool integration

Out-of-Scope Uses

• —Harmful, illegal, or deceptive content generation
• —Impersonation of real individuals without consent
• —High-risk decision-making without human oversight
• —Surveillance or tracking of individuals
• —Any use that violates applicable laws or regulations

Safety & Limitations

Known Limitations

• —Model scale: At ~0.3B parameters, this is an ultra-compact model. Several frontier-scale benchmarks (GDPval-AA, Terminal-Bench Hard, AA-LCR, CritPt) produce no discriminative signal at this model size, as the base Qwen3-0.6B itself scores near zero on them.
• —Thinking mode: Performance differs substantially between thinking and non-thinking modes across benchmarks. Users should evaluate both modes for their specific use case.
• —Tool calling: While fine-tuned for tool use, accuracy and reliability of tool calls should be validated for production use cases given the model's compact size.

Recommendations

• —Use human oversight for critical applications
• —Perform task-specific evaluation prior to deployment
• —Test both thinking and non-thinking modes for your use case
• —Validate tool-call outputs before executing them in production

Model Information

Citation

If you use this model, please cite the base model and this variant:

@misc{qwen3technicalreport,
  title         = {Qwen3 Technical Report},
  author        = {Qwen Team},
  year          = {2025},
  eprint        = {2505.09388},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CL},
  url           = {https://arxiv.org/abs/2505.09388}
}
@misc{littlelambtc,
  title  = {LittleLamb Tool-Calling: Compressed Qwen3-0.6B with Tool-Use via CompactifAI},
  author = {Multiverse Computing},
  year   = {2026},
  url    = {https://huggingface.co/MultiverseComputingCAI/LittleLamb-ToolCalling},
  note   = {Model developed based on Qwen/Qwen3-0.6B using CompactifAI technology, fine-tuned for tool calling}
}

Built by [Multiverse Computing](https://multiversecomputing.com/?utm_source=huggingface&utm_medium=referral&utm_campaign=hf_presence_0626&utm_content=littlelamb_tc_yaml_website) · Report an issue · Discord