LittleLamb 0.3B Tool-Calling
Powered by CompactifAI
Tiny Model · 50% Compressed · Native Tool Calling · Thinking & Non-Thinking Modes
Table of Contents
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.
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 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
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, top_p = 0.95, top_k = 20, min_p = 0
- Non-thinking mode (
enable_thinking=False, per Qwen3-0.6B instruct): temperature = 0.7, top_p = 0.8, top_k = 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, top_p = 0.95, top_k = 20, min_p = 0
- Non-thinking mode (
enable_thinking=False, per Qwen3-0.6B instruct): temperature = 0.7, top_p = 0.8, top_k = 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 blocked: Intelligence Thinking]
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 blocked: Performance]
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:
Built by Multiverse Computing · Report an issue · Discord