Tulu 3 70B
Tulu 3 at 70B. AI2's fully-open instruct fine-tune — research transparency at scale.
Our verdict
Positioning
Tulu 3 70B is Allen Institute for AI's (AI2) 70B-parameter instruction-tuned model — a fully open pipeline from base model through instruction tuning, RLHF, and evaluation. Built on the Llama 3.1 70B base with AI2's open instruction-tuning methodology, Tulu 3 represents the "open science" approach to instruction-following: every component of the training pipeline (data, code, evaluation) is publicly released. For operators who value transparency, reproducibility, and fully open training pipelines, Tulu 3 is the reference 70B instruction-tuned model.
Strengths
- Fully open training pipeline. AI2 releases the training data, instruction-tuning recipes, RLHF methodology, and evaluation framework. Every component from base model to final tuned model is documented and reproducible. Unique among 70B-class instruction-tuned models.
- AI2's instruction-tuning research quality. The Tulu lineage (Tulu 1 → 2 → 3) has produced published research on instruction-tuning methodology, with Tulu 3 incorporating lessons from multiple generations of open instruction-tuning research.
- Licensing through the open pipeline. While the base Llama 3.1 model carries the Llama Community License, AI2's training artifacts (data, code, evaluation) are openly licensed. Operators can reproduce the training pipeline with different base models if Llama's license is a concern.
- Competitive instruction-following benchmarks. Tulu 3 70B's instruction-following performance is competitive with other 70B instruction-tuned models on AlpacaEval, MT-Bench, and general instruction-following benchmarks.
- Strong coding and reasoning from the Llama 3.1 base. The underlying 70B model provides competitive reasoning, coding, and general knowledge capability from Meta's training infrastructure.
- 70B scale fits consumer/workstation hardware. Q4 at ~42 GB fits Mac Studio M3 Ultra or dual RTX 4090.
Limitations
- Inherits Llama 3.1 Community License restrictions. The base model is Llama 3.1 70B, carrying the 700M MAU clause and Llama use restrictions. The open training pipeline is open, but the model weights carry Llama's license.
- Instruction-tuning quality is competitive but not class-leading. Dedicated instruction-following specialists like WizardLM-2 8x22B or API-hosted models (GPT-4, Claude) may outperform Tulu 3 on complex instruction-following tasks.
- Base model is Llama 3.1, not 3.3 or 4. The underlying base model is from the Llama 3.1 generation — knowledge cutoff is earlier and some Llama 3.3/4 architectural improvements are absent. The model's strength is the open training pipeline, not the base model generation.
- No vision or multimodal capability. Text-only. For instruction-tuned VL models, consider Llama 3.2 90B Vision Instruct.
- AI2 research focus vs production optimization. Tulu 3 is primarily a research output — the training pipeline is optimized for transparency and reproducibility, not for production inference throughput or latency. Production deployment may require additional optimization.
Real-world performance
- vs Llama 3.3 70B: Tulu 3 is instruction-tuned on Llama 3.1; Llama 3.3 is the next-generation base. Llama 3.3 70B likely has stronger base capability; Tulu 3 has AI2's open instruction-tuning pipeline advantage. Pick by base model generation vs open pipeline preference.
- vs Llama 3.1 Nemotron 70B Instruct: Both fine-tunes of Llama 3.1 70B. Nemotron 70B has NVIDIA's distillation and optimization pipeline; Tulu 3 has AI2's fully open training pipeline. Pick by optimization depth (Nemotron) vs openness (Tulu 3).
- vs WizardLM-2 8x22B: Different architectures (MoE vs dense) and different training approaches. WizardLM-2 likely has stronger instruction-following on complex tasks; Tulu 3 has the open pipeline transparency advantage.
Should you run this locally?
Yes if you value fully open, reproducible training pipelines over maximum benchmark performance, can accept the Llama 3.1 base license, and have workstation-class hardware. Tulu 3's "open science" approach is unique and valuable for operators who want to understand and potentially reproduce their model's training.
No if you need maximum instruction-following quality at any cost (pick WizardLM-2 8x22B or API alternatives), the Llama license is incompatible, or you prefer a more recent base model generation (pick Llama 3.3 70B).
How it compares
- vs Llama 3.3 70B: Tulu 3 is open-pipeline instruction-tuned Llama 3.1; Llama 3.3 is newer base generation.
- vs Llama 3.1 Nemotron 70B Instruct: Both Llama 3.1 fine-tunes. Nemotron for NVIDIA optimization; Tulu for open pipeline.
- vs WizardLM-2 8x22B: Different architectures and training philosophies. Different strengths.
- vs Qwen 2.5 72B Instruct: Qwen 2.5 72B uses the Qwen license; Tulu is Llama-based with open pipeline.
Run this yourself
- Datacenter: Single A100 80GB at AWQ-INT4 with vLLM.
- Workstation: Mac Studio M3 Ultra (96 GB or 256 GB) at Q4. The 43 GB file fits either.
- Consumer: Single RTX 5090 (32 GB) holds only part of the 43 GB Q4_K_M file, so it needs partial offload to system RAM.
- Vendor: huggingface.co/allenai/Llama-3.1-Tulu-3-70B
Overview
Tulu 3 at 70B. AI2's fully-open instruct fine-tune — research transparency at scale.
How to run it
Tulu 3 70B is Ai2's instruction-tuned 70B model based on Llama 3.1 70B. Tulu is Ai2's research fine-tune focused on improving instruction-following with a curated dataset mix (open-source post-training pipeline). Run at Q4_K_M via Ollama (ollama pull tulu3:70b) or llama.cpp with -ngl 999 -fa -c 8192. Q4_K_M file size 43 GB on disk. Minimum VRAM: 48 GB — RTX A6000 (48GB) at Q4_K_M for 4K context. RTX 4090 24GB holds only part of the 43 GB Q4_K_M file, so it needs partial offload to system RAM. Recommended: A100 80GB at AWQ-INT4 for serving. Standard Llama architecture — dropp-in compatible with any Llama inference stack. Tulu 3 is instruction-tuned (chat/agent focus). Use for: general chat, instruction-following, agent tasks, knowledge work. The weights are under the Llama 3.1 Community License. Context: Llama 3.1-level (128K, practical 8-16K on 48 GB).
Hardware guidance
Minimum for full GPU: 48 GB. Recommended: RTX A6000 48GB at Q4_K_M (8K). Optimal: A100 80GB at AWQ-INT4. VRAM math: 70B dense, Q4_K_M file = 43 GB. KV cache at 8K: ~2.7 GB. Total: ~46 GB at 8K. A6000 48GB: tight but possible at 8K. RTX 3090 24GB, RTX 4090 24GB and RTX 5090 32GB cannot hold the 43 GB file, so they need partial offload to system RAM. Dual RTX 4090 48 GB: Q4 at 8K is viable. Mac Studio M4 Max 64GB: Q4_K_M fits. AWQ-INT4 on A100 enables 32K context.
What breaks first
- Tulu chat template. Tulu 3 uses Ai2's chat template, which differs from standard Llama 3.1. Using the Llama 3.1 default template may produce subtly worse instruction-following. Use Tulu's template from tokenizer_config.json. 2. Q3 quality on instruction-following. Tulu's instruction-tuning is relatively shallow compared to base Llama training. At Q3, instruction adherence degrades more than base knowledge — the fine-tuned behavior is more quant-sensitive. 3. Ollama tags. Ollama's library has
tulu3:70b(43 GB, Q4_K_M), plus Q8_0 and FP16 tags. There is no Q3 tag.
Runtime recommendation
Common beginner mistakes
Mistake: Using Llama 3.1's default chat template with Tulu 3. Fix: Tulu 3 uses Ai2's template. Check tokenizer_config.json for exact format or use the model card's recommended template. Mistake: Assuming Tulu 3 matches Llama 3.3 70B quality. Fix: Tulu 3 is fine-tuned on Llama 3.1 70B, not 3.3. It's a different base model. Expect quality similar to Llama 3.1 70B with improved instruction-following. Mistake: Expecting Tulu 3 to follow system prompts as aggressively as command-r models. Fix: Tulu 3 is instruction-tuned but not specifically system-prompt-optimized. Longer system prompts may be ignored or partially followed. Mistake: Running at 128K context on consumer hardware. Fix: KV cache at 128K is about 43 GB on top of the 43 GB weights. Keep context 4-8K on 48 GB GPUs.
Family & lineage
How this model relates to others in its lineage. Family members share architecture and training-data roots; parent / children edges record direct distillation or fine-tune relationships.
Strengths
- Fully-open recipe at 70B
Weaknesses
- Llama Community license inherited
Quantization variants
Each quantization trades model quality for file size and VRAM. Q4_K_M is the most popular starting point.
| Quantization | File size | VRAM required |
|---|---|---|
| Q4_K_M | 43.0 GB | 48 GB |
At Q4 Tulu 3 70B needs about 48 GB of memory by our estimate, more than a 32 GB graphics card holds. Renting a GPU with enough memory (or several GPUs) by the hour is the practical way to try it before you plan hardware for it.
Referral links: RunLocalAI may earn a commission or account credits if you sign up and rent, at no extra cost to you. Hourly rates and which GPUs are listed change all the time, so check the provider's page before you start. How we make money.
Get the model
HuggingFace
Original weights
Source repository — direct quantization required.
Hardware that runs this
Cards with enough VRAM for at least one quantization of Tulu 3 70B.
Models worth comparing
Same parameter band, plus what's one tier above and below — so you can decide what actually fits your hardware.
Frequently asked
What's the minimum VRAM to run Tulu 3 70B?
Can I use Tulu 3 70B commercially?
What's the context length of Tulu 3 70B?
Source: huggingface.co/allenai/Llama-3.1-Tulu-3-70B
Reviewed by RunLocalAI Editorial. See our editorial policy for how we research and verify model claims.
Related — keep moving
Verify Tulu 3 70B runs on your specific hardware before committing money.