Groot-280B-A16B: open-weight model with 1M context, derived from DeepSeek

"GrootTeam" has released a family of open-weight models. The largest has 280B parameters and activates about 16B per token. The maker says it narrowly beats larger models like GLM-5.3-Flash on a 16-benchmark average. A Reddit user points out that these appear to be pruned (REAP) variants of DeepSeek and Qwen models.

Model releases Try it yourself Oct 31, 2026 4 min read Source: Reddit: lokale Modelle & Bild-KI

What this is about

A group called "GrootTeam" has published a family of open-weight reasoning models called "Groot" on Hugging Face. The largest variant, Groot-280B-A16B-261023, has about 280B parameters, of which roughly 16B are active per token. The maker describes the models as compact, easy to run, strong at reasoning and tool use, and frugal with tokens. On Reddit (r/LocalLLaMA), the model was posted as potentially the "best model under 500B parameters." The poster adds, though, that these appear to be REAPs of various DeepSeek and Qwen models. REAP probably refers to pruning rarely used experts from a MoE model; the model card doesn't explain it. Whether anyone has tried the models yet is unclear.

Architecture and tech

According to the model card, Groot-280B starts from DeepSeek-V4.1-Flash-1017. It is a natively multimodal Mixture-of-Experts model. In this design, many sub-networks ("experts") exist, but only a small share is used per token. The key specs:

40 layers (20 encoder and 20 decoder layers), hidden size 5120
192 routed experts plus 1 shared expert, with 6 active per token
Active parameters: about 8B in prefill (processing the input) and about 16B in decode (generating the response)
An additional 197B parameters of "Engram" memory, a token lookup table that, per the card, adds no active compute load but is included in the file size
14B parameters for MTP and DSpark draft layers (multi-token prediction and speculative decoding: the model guesses several tokens ahead to speed things up)
Context length of 1M tokens

The model runs in thinking mode by default. You can control thinking depth with an integer from 1 to 100 (reasoning_effort); the levels low/medium/high/max correspond to 50/62/75/100. According to the maker, all benchmarks were run at the maximum of 100.

Benchmarks and cost (maker's figures)

The maker claims the highest 16-benchmark average of all models shown under 552B parameters. The lead is minimal, though.

Model	Total parameters	Avg. of 16 benchmarks
Groot-280B-A16B	280B	58.85
GLM-5.3-Flash	320B	58.78
DeepSeek-V4-Flash-0731	284B	55.25

Groot beats both rivals on 8 of 16 benchmarks. The biggest gaps: NL2Repo-Bench 56.71 (vs. 48.57 / 39.20), SWE-bench Pro 63.47 (vs. 57.59 / 59.37) and AutomationBench 50.61 (vs. 46.44 / 40.33). On DeepSWE 1.1, it reaches 64.2% pass@1 at about $0.13 per task; GLM-5.3-Flash gets 63% at $0.24, and DeepSeek-V4-Flash gets 53% at $0.46. For the tests, the maker lists temperature 1.0, top_p 0.95 and 1M context. Some runs used agent harnesses such as Claude Code, and for HLE with tools, gpt-5.5 served as the judge.

On the smaller variants, the Reddit post quotes the maker's card: Groot-19B-A3B scores higher than the larger Qwen3.6-35B-A3B and Gemma-4-26B-A4B, and answers more concisely.

What you need to try it

The 280B model isn't for ordinary home PCs. The FP8/FP4 version weighs 365.8 GB, and the GGUF variant (UD-Q4_K_XL) weighs 356.2 GB. For the full 1M context entirely on GPU, the maker lists 4x 96 GB cards (H20, RTX PRO 6000 Blackwell), 4x H200, 8x H100 or 2x B300. If you have less VRAM, you'll have to offload parts to system RAM. The source gives no concrete offloading figures for Groot (only for DeepSeek: at least 256 GB of host memory). In short, you need hundreds of GB of storage and a lot of RAM. The smaller variants (19B-A3B, 65B-A6B) are more realistic for beginners, but the source offers no details on them. You serve it with vLLM or SGLang (tensor parallel 8 in the example) or via Transformers. Google Colab isn't enough for the large variant.

Our take

This release is interesting if you're looking for large agent models you can run locally. The numbers suggest a slimmed-down model can keep up with bigger ones, at a lower cost per task. There are caveats: all figures come from the maker itself, and independent tests are missing. The lead in the average (58.85 vs. 58.78) is practically within the noise. Also, per the Reddit comment, the models are derived from existing DeepSeek and Qwen models, and the model card itself names DeepSeek-V4.1-Flash-1017 as the starting point. The source doesn't state the license, so check it before commercial use. The hardware comparison also looks a bit selective: the maker stresses that Groot runs fully on GPU with 4x 96 GB, while DeepSeek doesn't.

Terms explained simply

Mixture-of-Experts (MoE): The model consists of many specialized sub-networks, and only a few of them work on each token. That makes it large but comparatively fast.
REAP: Probably a technique that removes rarely used experts from a MoE model to shrink it. The model card doesn't explain the term; it comes from the Reddit post.
Engram memory: A large lookup table for tokens that increases file size but, according to the maker, adds no extra compute load.
Speculative decoding: A small helper module guesses several tokens ahead and the main model checks them, which speeds up text output.
GGUF: A file format for quantized models, used for example in llama.cpp-based programs.
reasoning_effort: A dial from 1 to 100 that sets how long and how thoroughly the model thinks. More effort usually gives better results but costs more tokens.
pass@1: The share of tasks the model solves correctly on the first attempt.

Sources

Reddit: lokale Modelle & Bild-KI huggingface.co

#groot#moe#open-weights#deepseek#reasoning#gguf

Read the original source

Try it yourself: Groot-280B-A16B-261023

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

Groot-280B is a large reasoning model for coding, agent tasks and tool use, and it can also process images. It thinks step by step by default, and you can steer it with a dial from 1 to 100. With up to 1M tokens of context, it can keep very large codebases or documents in view. According to the maker, it sits narrowly ahead of GLM-5.3-Flash and clearly ahead of DeepSeek-V4-Flash-0731 on a benchmark average, at a lower cost per task. This hasn't been independently confirmed. It's based on DeepSeek-V4.1-Flash, so it's more of a further development than an entirely new model. It's too big for ordinary PCs; its smaller siblings (19B-A3B, 65B-A6B) are more practical.

Who is it worth it for?

Interesting for teams and enthusiasts with multi-GPU servers or lots of RAM who want a strong local agent/coding model. If you have a single gaming card, you're better off looking at the smaller Groot variants.

Ideas: What you can do with it

Coding agent for large repos

Connect the model to an agent tool through the OpenAI-compatible API and have it hunt for bugs or add features. The long context lets it read in entire projects.

Workflow automation

Use tool calls to let the model drive workflows like email sorting or spreadsheet upkeep. The benchmarks (AutomationBench, Toolathlon) target exactly these kinds of tasks.

Document analysis

Feed very long reports or contracts into the 1M context and ask targeted questions. You get summaries with references to where the information appears.

Local research assistant

Use a high thinking depth for tricky logic or math questions and compare the results with other models.

Model comparisons for teams

Run Groot alongside GLM or DeepSeek on your own hardware and check whether the maker's claims on cost and quality hold up for your tasks.

Size491.4 B parameters (16 billion active)

Download356 GB (about 7.9 hr at 100 Mbit/s)

Licensemit

TypeImage + text (understands images)

Hugging FaceGrootTeam/Groot-280B-A16B-261023

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 393 GB VRAMservers only, with multiple data-center GPUs (e.g. 8× H100) – fastest; with less VRAM, see the next line

Graphics card + system memory (MoE offloading) from approx. 9 GB VRAM + 512 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar

Mac (Apple Silicon M1–M5) too big for any MacThe GPU and CPU share the memory – the model can use about 70% of it

CPU only (no graphics card) Very slow without a graphics cardan estimated 2 words per second on a current desktop PC (MoE: only 16 billion parameters active per word). This requires at least 512 GB of RAM.

Storage approx. 358 GB freeModel download plus programs

Google Colab too big for Colabeven the largest Colab GPUs aren't enough

Pick the FP8+FP4 variant (365.8 GB) for multi-GPU servers with vLLM/SGLang, or the GGUF variant UD-Q4_K_XL (356.2 GB) for llama.cpp-style setups with a CPU/GPU mix. On smaller hardware, go for Groot-19B-A3B or Groot-65B-A6B.

Full 1M context entirely on GPU: 4x 96 GB cards (H20, RTX PRO 6000 Blackwell), 4x H200, 8x H100 or 2x B300 (maker's figure, estimated from memory capacity).
File size: 365.8 GB (FP8 + FP4 experts) or 356.2 GB (GGUF).
The Engram memory (about 197 GB) makes up a large part of the file size but costs no extra compute time.
With less VRAM, you need to offload to RAM; for the comparison model DeepSeek, the maker lists at least 256 GB of host memory.
Long contexts need a lot of additional memory; a shorter --max-model-len saves space.

Groß (491,4 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: too big for Colab – even the largest Colab GPUs aren't enough.

Download the notebook. Click the button and save the file.
Download colab.ipynb
Open Colab. Go to colab.research.google.com and sign in with your Google account.
Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU (with Colab Pro: L4 or A100) → Save.
Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 123 minutes here.
Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
```
ollama run hf.co/GrootTeam/Groot-280B-A16B-261023-GGUF:UD-Q4_K_XL
```
The first time, Ollama downloads the model (356 GB (about 7.9 hr at 100 Mbit/s)). After that, it's instant.
Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Prefer automatic? A script that picks the right variant for you

Download both files into the same folder: try_windows.ps1 demo.py
Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.

Paste this command and press Enter:

powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
Start the model. Paste the command (Cmd + V) and press Enter:
```
ollama run hf.co/GrootTeam/Groot-280B-A16B-261023-GGUF:UD-Q4_K_XL
```
The first time, the model is downloaded (356 GB (about 7.9 hr at 100 Mbit/s)).
Start typing. Type your question and press Enter. Quit with /bye.

Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
```
sudo ubuntu-drivers install
```

Install Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Start the model:
```
ollama run hf.co/GrootTeam/Groot-280B-A16B-261023-GGUF:UD-Q4_K_XL
```
Exit with /bye. Use ollama ps to check whether the model is running on the GPU.

Or let it pick the right variant automatically:

try_linux.sh

bash try_linux.sh
# mit Python/transformers statt Ollama:
MODE=hf bash try_linux.sh

Try it

Write a Python function that merges two sorted linked lists, and explain its runtime.

Analyze this repository and suggest a plan for migrating the tests from unittest to pytest.

Explain the difference between a MoE model and a dense model in simple terms, with an example.

Plan an automated workflow that reads incoming invoices from emails and enters them into a spreadsheet, and list the tool calls needed.

Find the bug in this stack trace and write a patch with a unit test.

Tips for better results

Lower reasoning_effort (e.g., to 50) for faster, cheaper answers on simple tasks.
For plain chats, set thinking_mode to "chat" to switch off thinking.
Use the recommended sampling values (temperature 1.0) instead of lowering them.
Test the smaller Groot variants first before you buy hardware for the 280B version.

If something goes wrong

The model card's vLLM command uses --tensor-parallel-size 8; with fewer GPUs, you need to adjust the value.

For tool calls and reasoning output, you must set the parsers (deepseek_v41); otherwise the thinking ends up in the normal text.

The recommended settings are temperature=1.0 and top_p=1.0 (local) or 0.95; max_tokens should be ≥ 256K, or long reasoning gets cut off.

You need a recent version of vLLM/SGLang/Transformers because the architecture is new.

The source doesn't state the license, so check Hugging Face before commercial use.

The repo names in the example commands sometimes differ (Groot/… instead of GrootTeam/…); use the name from the Hugging Face page.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: mit.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.