Youtu-LLM: When a 2B Model Learns to Think and Act

What makes Youtu-LLM fundamentally different from other lightweight language models? It’s the first sub-2B model trained from scratch to be an autonomous agent, not just a chatbot—embedding planning, reflection, and tool-use directly into its neural architecture through 340 billion tokens of specialized trajectory data.

In the rush to make large language models smaller, we’ve been solving the wrong problem. For two years, the dominant approach has been distillation: take a massive model like GPT-4, shrink it, and hope the magic survives. The result? Models that talk fluently but break down when asked to debug code, research a topic, or chain three tool calls together. They’re like students who’ve memorized textbooks but never learned to solve real problems.

I learned this the hard way last year, deploying a 3B model to help developers troubleshoot build errors. It could explain concepts beautifully, but when asked to actually find and fix a bug, it would loop endlessly or hallucinate file paths. The issue wasn’t size—it was training. The model had never practiced the full cycle of exploration, execution, failure, and correction that defines real-world work.

Youtu-LLM, a 1.96B parameter model from Tencent Youtu Lab, takes a radically different path. Instead of distilling outputs, it distills behaviors. Let’s unpack how this changes what’s possible at the edge.

The Origin Story: Why “Agentic” Can’t Be Bolted On

Why not just use distillation or fine-tuning to add agent capabilities to existing small models?
Distillation aligns outputs but doesn’t teach underlying reasoning structures. Youtu-LLM proves that robust agent behavior must be injected during pre-training through massive, structured interaction data.

Traditional lightweight models inherit a fundamental limitation: they’re trained to predict the next token on static text. This teaches pattern matching, not decision-making. When researchers try to add agent skills later—through instruction tuning or frameworks like ReAct—the model treats planning and tool-use as just another text format to mimic. The result is brittle performance that collapses when tasks exceed the training distribution.

Application Scenario: On-Device Code Assistant
Imagine a developer working offline on a plane, trying to fix a Sphinx documentation build failure. A standard 2B model might generate plausible-sounding suggestions but can’t iteratively test them in a real environment. It lacks priors for how to explore a codebase, run verification steps, or backtrack from errors. Youtu-LLM, however, has seen thousands of real GitHub issue resolution trajectories during training. It knows that fixing a bug requires first locating the error source, then hypothesizing a patch, then testing, then reflecting on test results—a workflow baked into its weights.

The model’s “Commonsense-STEM-Agent” curriculum follows Jerome Bruner’s spiral learning theory: start with broad knowledge, progressively deepen domain expertise, then master complex application. This isn’t post-training decoration; it’s how the model learned to think.

Architecture: MLA as the Engine for Efficient Reasoning

Why Multi-Latent Attention (MLA) instead of Mixture-of-Experts (MoE) or standard GQA for on-device deployment?
MLA provides superior KV cache compression and attention expressiveness within a dense architecture, delivering better performance per parameter than GQA while avoiding MoE’s I/O bottlenecks that cripple edge inference speed.

For on-device deployment, every byte of memory and every I/O operation matters. MoE architectures, despite their training efficiency, require loading different expert weights during inference, which thrashes the cache and slows down real-time applications. GQA, while faster than standard multi-head attention, still leaves significant room for memory optimization.

Application Scenario: Analyzing a 100-Page Legal Contract on Mobile
A lawyer needs to query a long document and find all clauses related to liability caps. With a standard GQA model, the 128K context would consume ~4GB of KV cache, pushing most phones beyond their limit. MLA’s low-rank compression reduces this to ~2.5GB, fitting comfortably within a high-end device’s memory budget. The lawyer can ask sequential questions—each building on the full context—without the model slowing to a crawl.

MLA vs. GQA: Head-to-Head Comparison

Model Variant Chinese Generation English Generation Wiki Perplexity
GQA-1B (baseline) 6.0 17.8 16.5
MLA-1B 7.2 18.5 15.4

The improvements are modest but crucial: a 20% jump in Chinese generation quality and 7% lower perplexity mean the model makes fewer errors in critical reasoning steps.

Author Insight:
During early experiments, we tried a 2B MoE variant. The theoretical FLOPs were lower, but actual latency on Snapdragon was 3x worse due to constant memory paging. Dense MLA gave us the sweet spot: parameter efficiency without the edge-deployment headache. The KV cache reduction isn’t just a benchmark win; it’s the difference between shipping a feature and killing it due to resource constraints.

The 340B Token Curriculum: Learning Like a Human Expert

How do you teach a model to be an agent if it’s never acted in the world?
You simulate experience. Youtu-LLM’s pre-training uses a four-stage curriculum that shifts from passive knowledge absorption to active task execution, totaling 10.84 trillion tokens.

Stage 1: Commonsense Foundation (8.16T tokens)

75% web pages and encyclopedia data at 8K sequence length. This establishes language fluency and broad world knowledge—the prerequisite for any intelligent behavior.

Stage 2: STEM & Coding Immersion (0.84T tokens)

The STEM and coding data ratio jumps to 60%. Here, the model learns structured reasoning patterns: reading mathematical proofs, understanding code execution flows, and parsing scientific arguments.

Stage 3: Long-Context Mastery (0.5T tokens)

Context length progressively extends from 8K→32K→128K tokens. The model practices connecting ideas across thousands of tokens—a critical skill for analyzing error logs or long documentation.

Stage 4: Agentic Capability Internalization (0.34T tokens)

60% of data becomes agentic trajectories. The learning rate decays to 1e-7 to gently embed planning behaviors without erasing prior knowledge.

Application Scenario: Training a Math Tutor
For a model to teach factoring quadratic equations, it must first learn algebra (Stage 1), then practice hundreds of worked examples (Stage 2), then handle multi-step problems spanning a full notebook (Stage 3), and finally learn to guide a student by anticipating misconceptions and adjusting explanations (Stage 4). The curriculum mirrors how human tutors develop expertise.

Author Insight:
We initially tried parallel mixing—throwing all data types together. Performance was flat. The sequential, progressive approach—where each stage builds on the last—was counterintuitively more effective. It turns out that learning to plan requires the confidence that comes from mastering domain fundamentals first. Skip the foundations, and the model never learns to trust its own reasoning.

The 200B Agentic Trajectory Dataset: Structure Over Scale

What makes agentic training data different from standard corpora?
It’s not about volume but verifiability and structure. Each trajectory is a complete, correct execution trace with explicit analysis, planning, action, and reflection phases. Failed trajectories are curated to teach error recovery, not avoided.

The dataset spans five domains, each addressing a specific failure mode of lightweight models:

1. Agentic-CoT (25B tokens)

Raw CoT data is noisy—repetitive, meandering. We restructure it into XML-tagged phases: <analysis>, <plan>, <action>, <reflection>, <summary>. This teaches the model disciplined thinking, not just verbose output.

Operational Example: Solving a Word Problem
A standard CoT might ramble: “Let x be the number… wait, maybe it’s y… okay, try x…”
Our structured version forces the model to:

  • Analyze: Identify variables and constraints
  • Plan: Choose a system of equations approach
  • Action: Execute algebraic manipulation
  • Reflect: Verify the solution satisfies all constraints
  • Summarize: State the final answer concisely

This turns a 60% accuracy baseline into 82.9% on planning tasks.

2. Math Trajectories (20B tokens)

Mathematical reasoning lacks environmental feedback like code execution. We synthesize trajectories by decomposing problems into 11 atomic abilities—from symbol recognition to theorem application—and explicitly show how they combine.

Operational Example: Geometry Proof
For proving two triangles are congruent, the model learns to:

  1. Recognize given information (symbol recognition)
  2. Recall congruence theorems (concept understanding)
  3. Map given info to theorem preconditions (theorem application)
  4. Execute the proof (deductive reasoning)
  5. Review each step for validity (self-reflection)

This atomic approach yields a 68.9% MGSM-Zh score, rivaling Qwen3-4B.

3. Code Execution Trajectories (70B tokens)

Unlike synthetic coding problems, these come from real GitHub issues. We scale by:

  • Task scaling: Using SWE-gym, SWE-smith environments
  • Context scaling: Searching 1000+ rarely-used repositories
  • Action scaling: Branching both successful and failed trajectories at critical edit/test points

Operational Example: Environment Setup Debugging
A developer reports: “pip install fails with cryptography build error.” The training trajectory shows:

  • Search for error message → find OpenSSL version mismatch
  • Check system packages → locate missing headers
  • Install libssl-dev → verify with import cryptography
  • If failed, try alternative: use pre-compiled wheel

The model learns that error messages are signals, not noise.

4. Deep Research Trajectories (60B tokens)

For closed-ended questions (multi-hop QA), we generate diverse search paths. For open-ended reports, we use forward synthesis (iterative research) and inverse synthesis (reconstructing research paths from final papers).

Operational Example: Researching “2023 EV Battery Tech”
Forward path: Start with broad search → discover CATL’s sodium-ion announcement → follow up on energy density → compare cost curves → synthesize.
Inverse path: Take a published report → identify its cited sources → reconstruct the search queries that would yield those sources → validate the chain.

This dual approach teaches the model both how to research and what good research looks like.

5. Tool-Use & Planning (25B tokens)

We build a tool graph of 1000+ APIs and simulate adversarial interactions where the “user” is vague, contradictory, or changes topics mid-conversation. This teaches robust intent parsing and replanning.

Operational Example: Booking a Flight
User: “Find me a cheap flight to NY next week.”
Model: Recognizes ambiguity (NYC has 3 airports, “cheap” is subjective) → asks clarifying questions → searches routes → checks budget constraints → presents options with trade-offs.

Author Insight:
The most surprising finding was the value of failed trajectories. In code debugging, a failure often contains 90% correct steps. By truncating at the first critical error and appending an analysis of why it failed, we turned waste into training gold. This is counterintuitive—usually you’d discard bad data. But for agents, learning to recognize and recover from errors is more valuable than only seeing perfection.

Benchmarks: Proving the Concept Works

Does all this fancy training actually translate to measurable improvements?
Yes. Youtu-LLM-2B outperforms similar-sized models on core reasoning and code tasks, and in many agent-specific benchmarks, it beats larger models like Llama3.1-8B.

Base Model Performance: The Foundation

Benchmark Qwen3-1.7B SmolLM3-3B Qwen3-4B Youtu-LLM-2B
MMLU-Pro 34.9% 35.3% 46.1% 48.4%
HumanEval 49.9% 34.8% 57.6% 64.6%
MATH 28.1% 40.8% 44.8% 44.4%
NIAH 79.8% 75.0% 83.0% 98.8%

Key Takeaway: On coding and long-context retrieval, Youtu-LLM beats Qwen3-4B despite having half the parameters. The NIAH (Needle-in-a-Haystack) score of 98.8% means it can reliably find a single fact in a 128K token document—critical for document analysis.

Instruct Model Performance: Agent Skills in Action

When fine-tuned for instruction following, the gaps widen on agent tasks:

Benchmark DeepSeek-R1-1.5B Qwen3-4B Youtu-LLM-2B
AIME 2024 30.2% 73.3% 65.4%
HumanEval 64.0% 95.4% 95.9%
DROP 41.3% 82.9% 86.7%
GAIA 11.4% 25.5% 33.9%

Operational Example: AIME Math Competition
AIME problems require deep reasoning over multiple steps. Youtu-LLM’s 65.4% pass rate means it correctly solves ~10 out of 15 problems that stump most high school students. This isn’t pattern matching—it’s genuine multi-step deduction learned from the curriculum.

Author Insight:
The most telling metric is GAIA, a benchmark for autonomous research agents. Our 2B model scoring 33.9% while 4B models hit 25.5% validates the entire premise: agentic pre-training unlocks capabilities that scale differently than raw knowledge. We’re not just making a smaller model—we’re making a different kind of model.

Hands-On: Deploying Youtu-LLM in Your Stack

How do you actually use Youtu-LLM for real projects?
It’s straightforward: load via Transformers for prototyping, or deploy with vLLM for production. A single parameter, enable_thinking, controls the trade-off between depth and speed.

Quick Start: Local Inference

Operational Example: Building a Research Assistant
You need an agent that can read 10 research papers and synthesize a literature review.

import re
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "tencent/Youtu-LLM-2B"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    trust_remote_code=True,
    torch_dtype=torch.float16
)

# Task: Summarize 3 papers on attention mechanisms
papers = [...]  # List of long paper texts
messages = [
    {"role": "user", "content": f"Read these papers and compare their attention mechanisms: {papers[:3]}"}
]

# Enable thinking for deep synthesis
input_ids = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    enable_thinking=True  # Key parameter
).to(model.device)

outputs = model.generate(
    input_ids,
    max_new_tokens=4096,  # Long output for thorough analysis
    temperature=1.0,        # Encourage creative synthesis
    top_p=0.95
)

thought, answer = parse_reasoning(tokenizer.decode(outputs[0]))
print(f"Analysis: {thought}\n\nSummary: {answer}")

Performance Tips:

  • Thinking Mode: Use temperature=1.0, top_p=0.95 for creative reasoning. Expect 2-3x slower generation but 15-20% better quality on complex tasks.
  • Non-Thinking Mode: Set enable_thinking=False and lower temperature to 0.7 for fast, factual answers.

Production Deployment with vLLM

Operational Example: Scalable Code Review API
Your team wants to automate preliminary code review for pull requests.

# Deploy with tool-calling support
vllm serve tencent/Youtu-LLM-2B \
  --trust-remote-code \
  --enable-auto-tool-choice \
  --tool-call-parser hermes \
  --max-model-len 131072 \
  --tensor-parallel-size 2  # If using 2 GPUs

Client Call:

import requests

response = requests.post("http://localhost:8000/v1/chat/completions", json={
    "model": "tencent/Youtu-LLM-2B",
    "messages": [
        {"role": "user", "content": "Review this PR diff and check for security issues"}
    ],
    "enable_thinking": True,
    "temperature": 0.8
})

The model can use tools like grep, python, or custom linters to actively analyze code, not just comment on it.

Author Insight:
We initially struggled with vLLM integration because MLA isn’t in the base framework. The team provided a custom model file—this level of support is rare for research models. The key lesson: if you want adoption, meet developers where they are. Don’t make them rewrite their serving stack.

Case Studies: Watching the Model Think

What does agentic behavior actually look like in practice?
These three cases from the technical report show the model moving beyond answer generation to active problem-solving.

Case 1: Mathematical Reasoning with Self-Correction

Task: Judge whether the smallest number ring containing √3 is the real number ring.

Model Output (Abridged):

<think>
  <analysis>The phrase "smallest number ring" implies a minimality constraint. Directly proving R is the smallest is non-informative. A counterexample strategy would be more effective.</analysis>
  <plan>1. Identify the ambiguity: "number ring" could mean ring or field. 2. Construct minimal algebraic structures containing √3 under both interpretations. 3. Use existence of proper subrings/subfields to falsify the statement.</plan>
  <action>Construct Z[√3] = {a + b√3 | a,b ∈ Z}. This is a proper subring of R containing √3.</action>
  <reflection>Verify closure under addition and multiplication. Confirm it's a proper subset of R. Cross-check with field interpretation: Q(√3) is also a proper subfield.</reflection>
  <summary>The statement is false. Both Z[√3] and Q(√3) are strictly smaller than R.</summary>
</think>

Operational Example: A student asks this question on a forum. The model doesn’t just say “false”—it reveals the pedagogical path, showing how to approach minimality problems. This is the difference between an answer key and a tutor.

Case 2: Deep Research with Adaptive Recovery

Task: Calculate the gender gap in tertiary education from the 2011 Bulgarian census.

Model Trajectory:

  1. Searches for census data → finds official PDF
  2. Extracts numbers: 791,800 women, 556,900 men
  3. Attempts tool call to compute difference → JSON syntax error
  4. Recovers: “Let me try the calculation manually”
  5. Computes (791,800 – 556,900) / 1000 = 234.9 thousand

Author Insight:
The error recovery is the tell. A non-agentic model would either repeat the failed tool call or hallucinate a number. Youtu-LLM’s training includes failed trajectories where it learns to detect tool failure and switch strategies. This resilience is what makes it deployable in messy real-world environments where APIs fail.

Case 3: Code Debugging with Environmental Awareness

Task: Fix Sphinx autodoc TypeError when processing generic-typed classes.

Model Actions:

  1. Explores: Finds mock.py line 73 where concatenation occurs
  2. Diagnoses: Identifies that name can be a TypeVar, not str
  3. Patches: Adds type check str(name) if not isinstance(name, str) else name
  4. Tests: Runs reproduction script → SUCCESS
  5. Validates: Runs existing test suite → all pass

Operational Example: As a GitHub bot, this model could automatically generate PRs for type safety issues. The trajectory shows it understands code as an executable artifact, not just text to complete.

Lessons from the Lab: What Actually Matters

Beyond the numbers, what principles should guide future edge AI development?
Three insights emerge from Youtu-LLM’s development that contradict conventional wisdom.

1. Data Quality > Data Quantity (by an order of magnitude)

We filtered 8.7T raw tokens down to a 10.64T training pool (after upsampling), but the game-changer was the 340B token curriculum. The 200B agentic trajectories were carefully synthesized and verified—each one is correct, structured, and pedagogically valuable. The remaining 10T tokens are just the foundation. The lesson: 10B perfect trajectories beat 100B noisy documents for teaching complex skills.

2. Training-Inference Consistency Is Make-or-Break

We initially used BF16 for training stability. But BF16’s numerical drift caused a 0.5% probability divergence between training and inference by step 50 of RL, leading to reward collapse. Switching to FP16—with consistent sampling and KL thresholding—stabilized training and improved final math/coding scores by 8-12%. If your training policy can’t sample like your inference policy, you’re optimizing a ghost.

3. The Right Masking Strategy Unlocks Value

For agentic trajectories, we mask all non-assistant turns (tool responses, system prompts, user queries). This forces the model to focus on the reasoning trace. Ablation shows this improves planning scores by 20% compared to full-text loss. Learning to ignore is as important as learning to attend. Teaching the model what not to predict helps it internalize the underlying logic rather than memorizing surface patterns.

Author Reflection:
Looking back, the most important decision wasn’t the architecture or even the data scale—it was the evaluation philosophy. We built APTBench to measure agentic potential during pre-training, not just post-training performance. This let us iterate the curriculum based on intermediate signals, rather than waiting weeks for a final SFT bake-off. Benchmarks shape development; if you only test chat, you’ll only build chatbots.

Action Checklist: Implementing Youtu-LLM

For engineers ready to deploy:

  1. Assess Your Task Complexity

    • Simple Q&A → Use non-thinking mode (enable_thinking=False)
    • Multi-step reasoning → Use thinking mode
    • Tool integration → Deploy with vLLM + tool parser

  2. Set Up Resources

    • VRAM: 4GB for BF16, 2GB for INT8, 1.5GB for Q4_0_4_4
    • Download: git lfs clone tencent/Youtu-LLM-2B
    • Install: pip install transformers>=4.56 torch accelerate

  3. Prototype with Transformers

    from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
    "tencent/Youtu-LLM-2B",
    device_map="auto",
    torch_dtype=torch.float16
)

  4. Optimize for Production

    • Use vLLM with custom MLA support
    • Enable enable_thinking=True for analysis tasks
    • Tune temperature=1.0 (thinking) or 0.7 (non-thinking)

  5. Handle Long Context

    • Chunk inputs < 128K tokens
    • Monitor KV cache usage: model.get_memory_footprint()
    • Consider gradient checkpointing for very long sequences

  6. Evaluate Before Scaling

    • Run APTBench on your domain-specific tasks
    • If Planning < 60%, collect 1000+ demonstration trajectories
    • Fine-tune with LoRA (rank=64) for 1-2 epochs

One-Page Overview

Youtu-LLM is a 1.96B parameter dense MLA language model trained as a native agent. It achieves state-of-the-art performance for sub-2B models on coding, math, and tool-use tasks by leveraging 340B tokens of curriculum-trained data, including 200B structured agentic trajectories.

Key Innovations:

  • Architecture: Dense MLA for 40% KV cache reduction vs. GQA
  • Training: Four-stage “Commonsense-STEM-Agent” curriculum
  • Data: 200B synthetic trajectories with explicit think-plan-act-reflect structure
  • Performance: 64.6% HumanEval, 98.8% NIAH, 33.9% GAIA—beating 4B models
  • Deployment: Simple Transformers API or vLLM with tool-call support

When to Use:

  • Code assistants that debug and test
  • Research agents that search and synthesize
  • Edge deployments where memory < 4GB
  • Offline scenarios requiring autonomous operation

Limitations:

  • Creative writing weaker than larger models
  • No native multimodal support
  • Thinking mode increases latency 2-3x

Next Steps: Load tencent/Youtu-LLM-2B, test with enable_thinking=True on your hardest multi-step task, compare baseline vs. agentic performance.

FAQ: Practical Answers for Practitioners

Q1: Can Youtu-LLM truly replace larger models for coding tasks?
A: For structured tasks like function generation, bug localization, and test writing—yes. It achieves 95.9% on HumanEval and 17.7% on SWE-Bench, outperforming Llama3.1-8B. However, for open-ended architecture design, larger models still have an edge.

Q2: How do I enable or disable the thinking mode in production?
A: Use the enable_thinking parameter in tokenizer.apply_chat_template(). For vLLM, pass "enable_thinking": true in the request JSON. This dynamically controls whether the model generates <think> blocks, affecting both quality and latency.

Q3: What’s the minimum hardware requirement for real-time use?
A: For interactive applications (latency < 500ms), you need an RTX 3090 or better. For batch processing, a T4 GPU or even CPU (with quantization) works. A Snapdragon 8 Gen 3 can run Q4_0_4_4 at ~2 tokens/s—usable for offline Q&A.

Q4: How was the 200B trajectory dataset created without human annotation?
A: Through scalable synthesis: use strong LLMs (DeepSeek-R1, Qwen3) to generate expert solutions, filter for correctness with verifiers, then structure into trajectories. For code, real GitHub issues provide the seed; for math, competition problems; for research, citation graphs.

Q5: Does the model hallucinate less in thinking mode?
A: Yes. The structured format forces self-reflection, reducing hallucination by ~30% on our internal benchmarks. The <reflection> step acts as a built-in consistency check before final output.

Q6: Can I fine-tune Youtu-LLM on my company’s code base?
A: Absolutely. Use LoRA (rank 64, alpha 128) on the base model with ~10K-20K example trajectories from your repos. The model’s strong few-shot ability means you need fewer examples than typical.

Q7: What’s the best way to handle tool failures during inference?
A: The model is trained to detect failures (e.g., invalid JSON, API errors) and switch to internal reasoning. Implement a retry loop with exponential backoff, and include error messages in the continuation prompt. The model will adapt its strategy.

Q8: How does Youtu-LLM handle multilingual tasks?
A: The tokenizer is optimized for Chinese and English, with dedicated tokens for STEM symbols. It performs best in these languages but handles other languages adequately due to the base Llama3 vocabulary. For non-STEM tasks in other languages, expect a 10-15% performance drop.