MagenticBrain

MagenticBrain is a 14B-parameter orchestration model from Microsoft Research AI Frontiers. It plans multi-step tasks, calls declared tools, and coordinates sub-agents. It does not execute actions itself — every real-world side effect happens inside a host harness.

The model is supervised fine-tuned from Qwen/Qwen3-14B on agentic data: function-calling corpora, file-system trajectories, terminal tasks, sub-agent delegation traces, and reasoning data. After supervised fine-tuning, it was further trained with reinforcement learning on in-house-constructed terminal tasks. It's co-designed with MagenticLite, our agentic application and harness, and that's the configuration it has been most thoroughly evaluated in.

We're releasing weights only. Inference code, training recipes, and the execution harness are part of MagenticLite.

Highlights

• Orchestration-first post-training. Specialized for planning, tool selection, multi-turn tool chaining, and sub-agent delegation. Not a general-purpose chat model.
• Structured tool calls in JSON. Tool schemas are passed in at inference time. The model selects only from declared tools and never invents new ones.
• Sub-agent delegation built in. Trained with explicit handoff traces to Fara1.5-9B, our computer-use sub-agent (browser and desktop control).
• Submit-to-terminate protocol. Every task ends with a dedicated submit signal, which is a protocol token, not an action. The harness uses it as the end-of-task indicator.
• 32K context. Enough headroom for system prompt + tool schemas + multi-turn trajectory state.
• Built on Qwen3-14B. Inherits the base model's reasoning and instruction-following.

Model Details

Recommended Deployment: MagenticLite

MagenticBrain is the orchestration model inside MagenticLite. The training mix, tool-call format, and submit/terminate protocol are calibrated against MagenticLite's execution loop. If you want the behavior MagenticBrain was trained for, run it inside MagenticLite.

The weights load in any compatible runtime (Transformers, vLLM, SGLang, TensorRT-LLM). If you integrate the model directly, you're responsible for the execution boundary: declaring the tool schema, parsing the model's JSON tool calls, executing tools under your own permissions, and handling the submit terminator.

Quickstart

Transformers

Requires transformers >= 4.51.0.

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "microsoft/MagenticBrain"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the contents of a file at the given path.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "submit",
            "description": "Signal that the task is complete.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]

messages = [
    {"role": "system", "content": "You are an orchestration agent. Plan steps and call only the tools declared below."},
    {"role": "user", "content": "Summarize the contents of /tmp/report.md."},
]

text = tokenizer.apply_chat_template(
    messages,
    tools=tools,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False,  # thinking is disabled by default for MagenticBrain
)

inputs = tokenizer(text, return_tensors="pt").to(model.device)
output_ids = model.generate(**inputs, max_new_tokens=1024)[0][inputs.input_ids.shape[1]:]
print(tokenizer.decode(output_ids, skip_special_tokens=True))

The model emits tool calls as JSON objects. Parse them, execute the tool in your host, feed the result back as a tool role message, and call generate again. Loop until the model emits submit.

vLLM

Serve with an OpenAI-compatible endpoint that exposes tool-calling:

vllm serve microsoft/MagenticBrain \
  --enable-auto-tool-choice \
  --tool-call-parser hermes \
  --max-model-len 32768

Then call /v1/chat/completions with tools=[...] as you would with any OpenAI-compatible tool-use model. Pass chat_template_kwargs={"enable_thinking": false} to match training-time defaults.

Recommended sampling

enable_thinking = false
temperature = 0.7
top_p = 0.8
top_k = 20
min_p = 0
presence_penalty = 1

MagenticBrain runs in non-thinking mode — keep enable_thinking=False in the chat template. Do not use greedy decoding; it causes endless repetition on this model family. Lower the temperature if you need stricter, more deterministic tool selection.

Training

Approach

Post-training has two stages. First, Supervised Fine-Tuning on a heterogeneous agentic data mix. Second, a reinforcement learning stage on in-house-constructed terminal tasks, further specializing the model for multi-step CLI execution. Thinking tokens are disabled by default (enable_thinking=False) to control verbosity and reduce looping on long trajectories.

Data sources

• Function-calling and orchestration: APIGen-MT, ToolACE, xLAM
• **MCP environ