Trinity Large Thinking: Arcee's 400B Open Reasoning Model

Trinity Large Thinking is the reasoning model from Arcee AI, announced on 1 April 2026 with open weights on Hugging Face. Arcee's launch post framed it as part of a push for serious American open models, in a field where most large open-weight releases come from Chinese labs.

For a developer, two less obvious facts matter more than the provenance. The licence changed after release, and the model's tool calling breaks in a specific, avoidable way if your client drops its reasoning tokens. Both are covered below, after the shape of the model itself.

A 400B model that runs like a 13B one

From the Hugging Face model card: about 398B total parameters with roughly 13B active per token. It is a sparse mixture-of-experts with 256 experts, one shared, and four routed per token, which Arcee describes as 1.56% sparsity. Six of the layers are dense.

The card says pretraining ran on 17 trillion tokens with data partner Datology, on 2,048 NVIDIA B300 GPUs, with Prime Intellect as the compute partner. Pretraining used an 8,192-token context, later extended to 512K. Post-training focused on agentic reinforcement learning with long reasoning chains and multi-step tool-calling trajectories.

That 13B active figure is unusually lean for the total size. It puts the per-token compute in the same range as a mid-sized dense model, while memory still has to hold all 398B parameters. Active vs total parameters goes into why that split decides both the price and whether self-hosting is realistic.

Trinity Large Thinking is built on Trinity-Large-Base. Its sibling Trinity-Large-Preview shares the architecture but is a lightly post-trained instruct model with no reasoning output; if you want the non-thinking variant, that is the one.

The licence changed after launch

Arcee shipped Trinity under Apache 2.0, and most launch coverage, including Arcee's own release post, says so. On 29 May 2026 Arcee announced that the whole Trinity family, Large Thinking included, was moving to OpenMDW-1.1, and that previously released models were updated to the new licence. The current model card lists OpenMDW-1.1.

Arcee's reasoning is that Apache 2.0 was written for source code and leaves ambiguity about weights, configs and evaluation materials, while OpenMDW covers all of a model release under one document. It says the new terms keep no field-of-use restrictions and need no separate commercial licence.

For most users this is a sideways move rather than a restriction. But if your legal review approved "Apache 2.0" in April, that approval names a document the current release no longer uses. Re-review against the licence file in the checkpoint you actually deploy, and record which revision you pulled. Open-weight model licences compared and open weights vs open source cover why that paperwork matters most when a product succeeds.

Keep the thinking, or the tool calls break

The model writes its reasoning inside a think block before answering. The card is unusually blunt about what that means for clients: thinking tokens must be kept in context for multi-turn conversations and agent loops.

In practice:

• Pass reasoning_content back on earlier assistant turns; the chat template re-wraps it in think tags.
• On OpenRouter, return the reasoning_details field unchanged.
• On tool-call turns, send an empty string as content, not null.
• When history must be trimmed, drop whole old turns rather than stripping reasoning from recent ones.

The failure mode when you get this wrong is specific: malformed tool calls, including tool-call markup appearing inside the reasoning field. Many generic OpenAI-compatible clients discard reasoning between turns by default, because that is the right behaviour for other models. With this one it quietly corrupts the loop. Check your client before blaming the model.

The cost side follows: keeping every reasoning trace means context grows faster than with a non-thinking model. Agent memory and context management covers compaction strategies that respect a constraint like this one.

What the benchmarks claim

Arcee's model card reports:

• PinchBench — 91.9, which Arcee ranks second behind Claude Opus 4.6; the card's comparison column puts Opus 4.6 at 93.3.
• Tau2-Airline — 88.0, and Tau2-Telecom — 94.7.
• AIME25 — 96.3; GPQA-Diamond — 76.3; MMLU-Pro — 83.4.
• SWE-bench Verified — 63.2, run in mini-swe-agent-v2.
• IFBench — 52.3.

The profile is consistent with the stated goal. The tau2 results, which test multi-turn tool use against a simulated customer and policy, are the strongest; coding is respectable but well behind the closed frontier, where the card's own comparison column puts Opus 4.6 at 75.6 on the same SWE-bench measure. These are vendor numbers and the comparisons are to models that have since been superseded, so treat them as a description of shape rather than rank.

Price, context and who should use it

OpenRouter lists it at $0.25 per million input tokens and $0.80 per million output at the time of writing, with cache reads at $0.06, a 262,144-token context and up to 80,000 output tokens. Arcee's launch post quoted $0.90 per million output tokens on its own API. The provider context limit is below the 512K the card describes, so check the provider if you need the full window.

A short decision rule:

• Use it for customer-facing or operational agents with many tool calls per session, where the tau2-style profile matches the job and low per-token cost compounds.
• Use it if you need a large open model with permissive terms and US provenance for procurement reasons.
• Look elsewhere for top-end coding agents, image input, or a client stack you cannot change to preserve reasoning.