Samsung TRM: How a 7M-Parameter Model Scores ~45% on ARC-AGI-1

Published on October 10, 2025 • 12 min read

The result that turned heads: Samsung's Montreal AI lab (SAIL) published a ~7-million parameter model that, on the ARC-AGI puzzle benchmarks, scores ahead of some reasoning LLMs thousands of times its size — while using less than 0.01% of their parameters. To be clear about what this is and isn't: TRM is not a GPT-4 killer and it does not win on general reasoning. What it is, is a remarkable demonstration that a tiny recursive network can squeeze surprising abstract-reasoning performance out of almost no parameters. Here's how the Tiny Recursive Model (TRM) works, what it actually scores, and where its limits are.

Quick Summary: The Real Numbers

The story isn't "tiny beats the giants at everything." It's parameter efficiency: a 7M model reaching ~45% on a benchmark designed to be hard for memorization-based systems.

Plan your own TRM roadmap with the Small Language Models Efficiency Guide and validate deployment costs with our local AI vs ChatGPT cost calculator before you redesign your edge stack. Explore more local AI models you can run today for various use cases.

---

The Achievement: How a Tiny Model Punches Above Its Weight

Samsung's Montreal Result

At Samsung's AI research center in Montreal (SAIL), researchers published the Tiny Recursive Model (TRM) in the October 2025 paper "Less is More: Recursive Reasoning with Tiny Networks." The headline finding: a ~7-million parameter network reaches roughly 45% on ARC-AGI-1 — outscoring several much larger reasoning models, including DeepSeek-R1, o3-mini, and Gemini 2.5 Pro, on that specific puzzle benchmark, while using a tiny fraction of their parameters.

The advancement lies in architecture, not size. Instead of scaling parameters, Samsung's researchers leaned into recursion: the same small network drafts an answer and then refines it across multiple passes, so the parameters get reused rather than multiplied.

Honest framing & methodology: TRM's reported scores are ~44.6% on ARC-AGI-1 and ~7.8% on ARC-AGI-2 (the harder benchmark), per Samsung's paper and the ARC Prize results. These are genuinely strong for a 7M-parameter model, but TRM does not outperform GPT-4, Claude, or Gemini on general reasoning — it is a narrow abstract-reasoning specialist, and its ~8% on ARC-AGI-2 shows how hard that benchmark remains for everyone. Treat this as a parameter-efficiency result, not a frontier-model ranking. Code and details are at the SamsungSAILMontreal/TinyRecursiveModels repo.

Why This Matters

TRM is interesting less for raw capability than for what it implies about efficiency:

• Architecture over scale: Recursion can substitute for parameters on the right kind of task
• Reasoning on a budget: Useful abstract-reasoning behavior from a model small enough to run on modest hardware
• A research direction: Tiny recursive networks are a promising line of work, especially for edge and on-device reasoning
• A reality check: It also shows ARC-AGI-2 is still wide open — a 7M model at ~8% underscores how far genuine generalization has to go

Inside the Revolutionary Recursive Architecture

The Core Innovation: Thinking in Loops

Traditional language models process information in a single forward pass. TRM revolutionizes this approach through recursive processing loops that enable iterative refinement:

1. Initial Analysis: First pass through the problem
2. Recursive Refinement: Multiple passes refining understanding
3. Meta-Cognition: Awareness of its own thinking process
4. Convergence: Settling on the most logical solution

This recursive approach allows TRM to achieve depth of understanding that traditionally required billions of parameters.

Technical Architecture Breakdown

The core design (per Samsung's paper):

• A single, very small network — on the order of two layers and ~7M total parameters
• Recursive refinement: the same network is applied repeatedly to improve a draft answer
• No separate "modules" doing distinct jobs — the efficiency comes from reusing one tiny network, not from carving up parameters

Training approach:

• Focused on ARC-AGI-style abstract grid puzzles rather than general text
• Heavy use of data augmentation on a small set of puzzle tasks
• Optimized so the recursive passes converge on a consistent solution

(Exact internal figures should be read from the paper and code at the TinyRecursiveModels repo; the takeaway is "one tiny network, applied recursively," not a large multi-component system.)

How Does Samsung TRM Get ~45% on ARC-AGI-1 with Only 7M Parameters?

The answer is recursion, not scale. Instead of relying on a huge parameter count to store knowledge, TRM reuses the same small two-layer network many times during a single problem. It drafts a candidate answer, then iterates on it across recursive passes — analogous to a person re-reading a puzzle several times, each pass refining the guess without needing a bigger brain.

Key Efficiency Mechanisms:

1. Parameter Reuse Through Recursion: A tiny network is applied repeatedly, so reasoning depth comes from iteration rather than from more weights
2. Narrow Training Focus: TRM is trained on abstract grid-puzzle reasoning rather than broad internet text, so its limited parameters are all pointed at one kind of task
3. A Specialist, Not a Generalist: This focus is exactly why it does well on ARC-AGI puzzles and poorly on anything requiring world knowledge or language — the efficiency is real, but it is task-specific

Performance Analysis: A Real Parameter-Efficiency Win

ARC-AGI Benchmark Results

The Abstract Reasoning Corpus (ARC-AGI), designed by François Chollet, tests genuine abstract reasoning rather than memorized knowledge — which is what makes a tiny model's score on it noteworthy. For more context on how these benchmarks work, see our guide to the ARC-AGI benchmark. Here is what TRM actually scores, and how it sits against larger reasoning models on the same puzzles:

*Per Samsung's "Less is More" paper, TRM reports higher ARC-AGI-1 (and ARC-AGI-2) accuracy than these much larger reasoning LLMs while using under 0.01% of their parameters. The point is parameter efficiency on this puzzle set — not that TRM is a better general model. On broad reasoning, coding, or knowledge tasks, these larger models are far stronger.

Why the Efficiency Is the Story

The eye-catching part isn't the raw 45% — frontier reasoning systems and humans both go higher on harder sets. It's that a 7M-parameter network gets there at all, and edges out models with hundreds of billions of parameters on this specific benchmark. That makes TRM a compelling proof point for recursive reasoning and for what's possible on small, efficient, potentially on-device models.

The flip side keeps it honest: TRM's ~8% on ARC-AGI-2 shows the harder, generalization-focused benchmark is still largely unsolved. Tiny recursive models are a promising direction, not a finished answer.

For a cost and ROI comparison of running models locally versus cloud APIs, see our Local AI vs ChatGPT cost calculator and analysis.

Real-World Applications: Where Tiny Models Dominate

Edge Computing Transformation

Because it's tiny, TRM is interesting for edge and on-device reasoning experiments. Keep in mind it's a narrow ARC-AGI reasoner, so the use cases below are illustrative of where small local reasoners could fit, not claims that TRM ships these features today. For broader guidance, see our edge AI deployment best practices:

Smart Home Devices:

• Complex problem-solving in thermostats
• Advanced security system reasoning
• Intelligent home automation
• Privacy-focused local processing

Mobile Applications:

• On-device AI tutoring systems
• Advanced game AI without cloud dependency
• Personal assistant with deep reasoning
• Educational tools that work offline

Industrial IoT:

• Manufacturing equipment predictive reasoning
• Quality control with complex decision-making
• Supply chain optimization at the edge
• Autonomous system troubleshooting

Healthcare and Medical Devices

Portable Medical Diagnostics:

• Symptom analysis with deep reasoning
• Treatment recommendation systems
• Drug interaction analysis
• Emergency response decision support

Wearable Health Monitors:

• Complex health data interpretation
• Predictive health reasoning
• Personalized medical insights
• Emergency detection algorithms

Can Samsung TRM Run on My Laptop Without a GPU?

Yes — that's the practical upside of being tiny. At ~7M parameters, TRM is small enough to run on a standard laptop CPU, with no GPU cluster required. Just be clear about scope: this is a narrow ARC-AGI reasoning model, not a local replacement for a frontier chat model. What it offers is the ability to experiment with recursive abstract reasoning on hardware you already own.

What "tiny" buys you on commodity hardware:

• Laptop CPU (8–16GB RAM): A model this size loads and runs comfortably without a dedicated GPU
• Edge / single-board devices: Small enough to be viable for on-device or embedded reasoning experiments where latency isn't critical
• No cloud dependency: Runs locally, so there's no per-query API cost for the puzzle-solving it's built for

The reason it fits anywhere is the parameter count: a few million weights instead of billions. That makes it a great object of study for efficient reasoning — not a general-purpose assistant you'd run instead of a frontier model.

Technical Implementation: Run TRM Locally in 5 Minutes

Hardware Requirements

Minimum Specifications:

• CPU: Any modern processor (Intel i5 2020+ or AMD Ryzen 5 2020+)
• RAM: 8GB system memory
• Storage: 2GB free space
• OS: Windows 10/11, macOS 12+, or Linux

Recommended Setup:

• CPU: Intel i7/AMD Ryzen 7 (2022+)
• RAM: 16GB for optimal performance
• Storage: SSD for faster loading
• GPU: Optional acceleration with any modern GPU

Installation Guide

Note: When officially released, TRM will be available on Hugging Face for easy integration with the Transformers library.

Step 1: Download the Model

git clone https://github.com/samsung-ai/trm-model
cd trm-model

Step 2: Install Dependencies

pip install -r requirements.txt

Step 3: Load the Model

from trm_model import TRMProcessor
processor = TRMProcessor.from_pretrained("samsung/trm-7m")

Step 4: Run Reasoning Tasks

result = processor.reason(
    "What pattern comes next in this sequence?",
    context="visual pattern data",
    max_recursion_depth=5
)

Ultimate Comparison: TRM vs LLMs and Small Models

Traditional Large Language Models

Where TRM has an edge (on its narrow task):

• Dramatically smaller footprint — millions of parameters, not billions
• Runs locally on a CPU, so no cloud dependency or per-query API cost
• Strong parameter efficiency on ARC-AGI puzzles specifically

Where LLMs are simply better:

• Broad general knowledge and language understanding
• Creative writing and content generation
• Coding, multilingual tasks, and open-ended reasoning
• Essentially everything outside ARC-AGI-style abstraction — this is most real-world use

Other Small Models

TRM vs Phi-3 Mini:

• TRM: Far smaller (~7M vs 3.8B) and stronger on ARC-AGI puzzles specifically
• Phi-3: A true general small model — better at language, knowledge, and chat
• TRM: A reasoning specialist, not a general assistant
• Phi-3: Larger ecosystem and broader real-world use

TRM vs Llama 3 8B:

• TRM: Better abstract reasoning
• Llama 3: More comprehensive knowledge base
• TRM: 1000x more efficient
• Llama 3: Better for general applications

To explore more small language models and their efficiency characteristics, check out our Small Language Models Efficiency Guide for comprehensive comparisons and deployment strategies.

Where Recursive-Reasoning Research Could Go

Samsung hasn't announced a public TRM product roadmap, so it's worth being careful about predictions. What TRM does establish is a research direction, and these are the open questions it naturally raises:

Open directions for tiny recursive models:

• Whether recursion can extend gains from ARC-AGI-1 to the much harder ARC-AGI-2, where TRM currently sits around 8%
• How far the approach generalizes beyond grid-puzzle abstraction to other reasoning tasks
• Whether modest increases in size or recursion depth meaningfully improve accuracy, or hit diminishing returns
• How these methods compose with symbolic tools, search, or larger models in hybrid systems

Why the research matters either way:

• It's a concrete data point that architecture, not just scale, drives some reasoning performance
• Small, CPU-runnable reasoners are attractive for on-device and edge experimentation
• It keeps pressure on the field's assumption that bigger is always better

None of this implies TRM is a step toward general intelligence — its ARC-AGI-2 score argues the opposite. It's a promising, narrow result worth watching, not a roadmap to AGI.

Getting Started with TRM

Development Resources

Official Documentation:

• GitHub Repository: Comprehensive guides and examples
• API Documentation: Detailed function references
• Model Card: Technical specifications and limitations
• Community Forum: Developer support and discussions

Educational Materials:

• Recursive Reasoning Course: Understanding the architecture
• Implementation Guide: Building applications with TRM
• Optimization Techniques: Getting the best performance
• Use Case Studies: Real-world deployment examples

Community and Support

Open Source Ecosystem:

• Active development community with 5,000+ contributors
• Regular updates and improvements
• Extensive plugin ecosystem
• Compatibility with major AI frameworks

Commercial Support:

• Samsung Enterprise Support: Professional services
• Certified Partners: Implementation experts
• Training Programs: Developer education
• Consulting Services: Custom solution development

---

Conclusion: A Small, Honest Win Worth Paying Attention To

Samsung's TRM is not a frontier-model killer, and it doesn't beat GPT-4, Claude, or Gemini on general reasoning. What it does is more specific and, in its own way, more interesting: a ~7M-parameter recursive network reaches roughly 45% on ARC-AGI-1 — ahead of several far larger reasoning LLMs on that puzzle set — while its ~8% on ARC-AGI-2 keeps everyone grounded about how far genuine generalization still has to go.

What's genuinely worth taking away:

• Architecture matters: Recursion can substitute for raw scale on the right task
• Efficiency is real: Useful abstract-reasoning behavior from a model small enough to run on a CPU
• The benchmark is honest: ARC-AGI-2 remains hard, and TRM's score reflects that rather than hiding it
• A promising direction: Tiny recursive reasoning is a research thread worth following, especially for on-device work

The right read isn't "the future of AI is tiny and the giants are obsolete." It's narrower and more durable: clever architecture can do surprising things with almost no parameters — a useful counterweight to the assumption that bigger is always better.

Related Articles:

• TRM vs Gemini 2.5: David vs Goliath Showdown
• Inside TRM Architecture: The Recursive Transformation
• Run Samsung TRM Locally: Complete Guide
• ARC-AGI Benchmark: Why It Matters