Groot-238B-A18B-261023

Groot is a family of open-weight reasoning models for complex real-world tasks. The models are compact and easy to deploy, strong on reasoning and tool-using workloads, and efficient with token budgets.

Groot-238B-A18B-261023 has 238B total parameters and activates about 18B per token. It starts from GLM-5.3-Flash and is tuned for reasoning and tool-using workloads. It is smaller than GLM-5.3-Flash (320B) and DeepSeek-V4-Flash-0731 (284B), and it beats both on six agentic benchmarks.

Where it runs. We release FP8 and GGUF (UD-Q4_K_XL) weights. The device fits below are estimated from memory capacity. FP8 runs the full 1M context on 2x H200, 4x H100 80GB, or 4x 96GB cards (H20, RTX PRO 6000 Blackwell). Its weights are small and its KV cache is light, so after loading there is still room for several 1M-token requests at once. Compared with GLM-5.3-Flash: on 2x H200 Groot runs 1M while GLM-5.3-Flash does not load, and on 4x H100 Groot leaves about 87GB free while GLM-5.3-Flash leaves about 14GB, not enough for a 1M context.

Model size vs. capability

The chart compares total model parameters with the unweighted average across all 16 benchmarks. Smaller models appear farther left and higher average scores appear higher. Groot-238B-A18B uses 16.2% fewer total parameters than DeepSeek-V4-Flash-0731 and 25.6% fewer than GLM-5.3-Flash. It averages 57.89, which is 2.64 points above DeepSeek-V4-Flash-0731 and 0.89 points below GLM-5.3-Flash. At a smaller total size, it stays close to GLM-5.3-Flash's average and leads both on six agentic benchmarks listed below.

Benchmarks

Accuracy. Groot-238B-A18B-261023 beats both GLM-5.3-Flash and DeepSeek-V4-Flash-0731 on ALE (47.42 vs 44.45 / 16.53), Toolathlon Verified (71.60 vs 70.06 / 70.37), AutomationBench (47.67 vs 46.44 / 40.33), DeepSWE 1.1 (65.13 vs 63.40 / 40.71), NL2Repo-Bench (50.18 vs 48.57 / 39.20) and BFCL v4 (74.81 vs 74.17 / 73.11).

Cost. On DeepSWE 1.1 it sits in the top-left of the chart below: 65.1% pass@1 at about $0.14 per task, versus 63% at $0.24 for GLM-5.3-Flash and 53% at $0.46 for DeepSeek-V4-Flash. It is both more accurate and cheaper, because it is a smaller model.

* Each benchmark was evaluated in thinking mode at its default reasoning effort (max). Unless otherwise stated, sampling uses temperature=1.0, top_p=0.95, and a 1M-token context window.
* Terminal-Bench 2.1: Evaluated with the Claude Code agent; max_output_tokens=128K, max_turns=500, 12h timeout; temperature=1.0, top_p=0.95.
* ALE Agent: Evaluated with ale_claude on top of Claude Code 2.1.170; max_output_tokens=128K, 4h timeout (extended up to 8h for specific long-running tasks); temperature=1.0, top_p=0.95.
* Toolathlon Verified: Reported as pass@1, averaged over 3 independent runs; temperature=1.0, top_p=0.95.
* AutomationBench: Evaluated on AutomationBench v1.0.6; max_turns=50; temperature=1.0, top_p=0.95.
* JobBench: max_tokens=200K, 600s timeout; temperature=1.0, top_p=0.95.
* DeepSWE 1.1: Evaluated with the mini-SWE-agent scaffold; 11h timeout; temperature=1.0, top_p=0.95.
* SWE-bench Pro: Evaluated with the SWE-agent scaffold; temperature=1.0, top_p=0.95.
* NL2Repo-Bench: Evaluated with the Claude Code agent; max_turns=1000, 80K context window; temperature=1.0, top_p=0.95.
* HLE (with tools): Evaluated with gpt-5.5 as the judge model; max_iterations=1000, 6h timeout, 256K context window; temperature=1.0, top_p=0.95.

---

Model Overview

• Type: Natively multimodal Mixture-of-Experts causal language model
• Total Parameters: ~238B, plus a 5.6B MTP layer
• Activated Parameters: ~18B per token
• Layers: 45 (first 3 dense, 42 Mixture-of-Experts)
• Hidden Size: 4096
• Experts: 216 routed + 1 shared, 8 routed experts activated per token
• Context Length: 1M tokens
• Precision: FP8 (E4M3, dynamic, 128x128 block scales) for the experts and most linear layers; embeddings, lm_head, routers, some attention projections and the vision tower stay in BF16; a GGUF release is also available
• Multi-Token Prediction: 1 layer

Available editions:

---

Quickstart

Groot-238B-A18B-261023 is a mixture-of-experts model with ~238B total parameters and ~18B activated parameters per token.

The model operates in thinking mode by default: thinking is emitted before the final answer. It supports a 1M-token context window and natively supports tool calling.

Notes

• The model supports controlling the thinking budget through the reasoning_effort parameter, which accepts three levels: low, high, and max. It defaults to max if not passed (or if set to any other value). To use low or high, pass them explicitly. For benchmark and leaderboard reproduction, keep the default max.
• In the chat template, clear_thinking defaults to false if not passed. For chat scenarios, explicitly pass clear_thinking=true.

---

Serving Groot-238B-A18B-261023

vLLM

Requires vLLM 0.29.0+. The following command serves the model with tensor parallel on 4 GPUs, an FP8 KV cache, and MTP speculative decoding:

vllm serve Groot/Groot-238B-A18B-261023 \
    --served-model-name Groot-238B-A18B-261023 \
    --tensor-parallel-size 4 \
    --kv-cache-dtype fp8 \
    --speculative-config '{"method":"mtp","num_speculative_tokens":5}' \
    --tool-call-parser glm47 \
    --reasoning-parser glm47 \
    --enable-auto-tool-choice

SGLang

sglang serve \
    --model-path Groot/Groot-238B-A18B-261023 \
    --served-model-name Groot-238B-A18B-261023 \
    --tp-size 4 \
    --reasoning-parser auto \
    --tool-call-parser auto

--reasoning-parser auto resolves to the model's thinking parser, so the OpenAI-compatible API places thinking in message.reasoning_content and the final answer in message.content; --tool-call-parser auto returns structured calls in message.tool_calls.

---

Using Groot-238B-A18B-261023 via the Chat Completions API

Before starting, make sure the SDK is installed and the API key and the API base URL are configured:

pip install -U openai

# Set the following accordingly
export OPENAI_BASE_URL="http://localhost:8000/v1"
export OPENAI_API_KEY="EMPTY"

Text Input

from openai import OpenAI

# Configured by environment variables
client = OpenAI()

messages = [
    {"role": "user", "content": "Write a Python function to merge two sorted linked lists."},
]

chat_response = client.chat.completions.create(
    model="Groot-238B-A18B-261023",
    messages=messages,
    temperature=1.0,
    top_p=0.95,
    extra_body={
        "chat_template_kwargs": {
            "clear_thinking": True,     # pass true for chat scenarios
            "reasoning_effort": "max",  # "low" | "high" | "max"; defaults to "max"
        },
    },
)

message = chat_response.choices[0].message
# reasoning_content holds the thinking trace; content holds the final answer.
print("reasoning:", getattr(message, "reasoning_content", None))
print("answer:", message.content)

On follow-up turns, read both reasoning_content and content. A thinking model can use either field around tool execution.

Tool Calling

The model emits well-formed function calls that the server parses into the standard tool_calls field:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="Groot-238B-A18B-261023",
    messages=[{"role": "user", "content": "What is the weather in Paris right now?"}],
    tools=tools,
    tool_choice="auto",
    temperature=1.0,
    top_p=0.95,
)

message = response.choices[0].message
print("reasoning:", getattr(message, "reasoning_content", None))
print("answer:", message.content)

tool_call = message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)
# -> get_weather {"city": "Paris"}

You can point any OpenAI-compatible SDK (Python, Node.js, etc.) or curl at the same /v1/chat/completions endpoint.

---

Hugging Face Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Groot/Groot-238B-A18B-261023"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    dtype="auto",
    device_map="auto",
)

messages = [{"role": "user", "content": "Give me a short introduction to large language models."}]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=8192,
    temperature=1.0,
    top_p=0.95,
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):]
print(tokenizer.decode(output_ids, skip_special_tokens=True))

---

Citation

If you use this model in your work, please cite it as:

@misc{groot2026,
  title  = {Scaling Down LLMs for Broader Deployment},
  author = {The Groot Team},
  year   = {2026},
}