Arcee Trinity Large Explained: America's 400B Open-Weight Model

Arcee Trinity Large is a 400-billion-parameter open-weight language model built by Arcee AI, a small American lab. The weights are published on Hugging Face. You can download them, run them on your own hardware, fine-tune them, and ship them in a commercial product.

That combination is rarer than it sounds. For two years the strongest downloadable models have mostly come from Chinese labs — DeepSeek, Qwen, Kimi K3, and the GLM family. Trinity Large is a US-built answer to that, from a company most buyers have never heard of.

This page is the hub for everything Arcee Trinity Large: what the model is, how it was trained, what license governs it, where the files live, and which teams should actually care.

What Is Arcee Trinity Large?

Arcee Trinity Large is a sparse mixture-of-experts (MoE) model with roughly 400 billion total parameters and about 13 billion active per token. Only a small slice of the network runs on any given token, so serving cost tracks the active count more than the total.

Arcee publishes the architecture openly. The model routes through 256 experts, activating 4 per token, on top of 6 dense layers. Arcee reports a native context window of 512K tokens.

The family ships in tiers, not as one file. That matters for buyers, because most workloads do not need the largest tier.

• Trinity Large — roughly 400B total parameters, about 13B active per token, 512K context. The flagship.
• Trinity Mini — 26B total, about 3B active per token, 128K context. Built for agents, tool calling, and structured output.
• Trinity Nano — 6B total, about 1B active per token, 128K context. The small end of the line.
• Trinity Large ships in several checkpoints: a chat-ready Preview, a Base checkpoint, a TrueBase checkpoint with no instruct data, and a separate Thinking model that produces reasoning traces.

Who Is Arcee AI?

Arcee AI is a small, venture-backed American AI lab founded in 2023. Mark McQuade is the CEO and co-founded the company with Jacob Solawetz and Brian Benedict. McQuade came out of Hugging Face, and the company's early reputation was built on small models and model-merging work, not frontier-scale pretraining.

The company is small by frontier-lab standards, which is the surprising part of the Trinity story: a team this size shipped a 400B model.

Funding was not easy. McQuade has said plainly of the raise: "Every tier-one VC pretty much said no." Arcee's published funding history and headcount are not fully disclosed on its own site, so treat third-party totals as estimates.

How Trinity Large Was Trained: 33 Days, 2,048 GPUs, $20 Million

Arcee pretrained Trinity Large in 33 days on 2,048 Nvidia B300 GPUs, at a stated all-in cost of about $20 million. That figure covers compute, salaries, data, storage, and operations — not compute alone.

The training data ran to 17 trillion tokens across three phases of 10T, 4T, and 3T. Arcee states that over 8 trillion tokens of synthetic data were generated for the run.

Twenty million dollars is a real number, and it is also a small one. Frontier labs spend that on a rounding error. The point Arcee is making is that a competitive open-weight model no longer requires a nine-figure training budget.

• Pretraining hardware: 2,048 Nvidia B300 GPUs.
• Pretraining duration: 33 days.
• Training tokens: 17 trillion, in phases of 10T, 4T, and 3T.
• Stated all-in cost: roughly $20 million, including salaries and operations.
• Pretraining sequence length: 256K, with 512K supported at inference.

What License Covers Trinity Large?

Trinity launched under Apache 2.0 and the whole family has since moved to the OpenMDW-1.1 license. Arcee announced the change in 2026 and applied it retroactively to already-released models, including Trinity Nano, Mini, Large, Large Thinking, and every quantized variant.

OpenMDW stands for Open Model, Data and Weights. It is a permissive license from the Linux Foundation written specifically for model releases, covering weights, configs, evaluation materials, and data under one instrument. Apache 2.0 was written for code and never spoke cleanly to weights.

Arcee's stated terms are permissive: commercial use is allowed, with no field-of-use restrictions and no separate commercial license to sign. You may inspect, post-train, self-host, distill, modify, and deploy the models commercially.

Where Do the Trinity Large Weights Live?

The Trinity Large weights are published on Hugging Face under the arcee-ai organization. Three Large checkpoints are listed: Trinity-Large-Preview, Trinity-Large-Base, and Trinity-Large-TrueBase.

Quantized builds exist too. Arcee's model card lists roughly ten quantized variants for llama.cpp, LM Studio, Jan, and Ollama, which is what makes the model reachable outside a datacenter.

You do not have to self-host. Arcee runs a managed OpenAI-compatible endpoint, and the models have appeared on third-party inference hosts including OpenRouter.

• Self-host from Hugging Face — full control, full hardware cost.
• Arcee's hosted API — an OpenAI-compatible endpoint with no GPU purchase.
• Third-party inference hosts — pay per token without running the model or signing with Arcee.
• Local quantized builds — realistic for the Mini and Nano tiers, demanding for Large.

What Does It Take to Actually Run It?

Trinity Large runs on the standard open-weight serving stacks, but the memory floor is the real gate. Arcee's model card names vLLM 0.11.1 or later with bfloat16, SGLang with an OpenAI-compatible API, Transformers with trust_remote_code enabled, and llama.cpp from build b7061 onward.

A 400B-parameter model at bfloat16 needs roughly 800 GB of memory before you add key-value cache for context. That is a multi-GPU server, not a workstation. Quantization cuts it, at some quality cost.

Arcee's hosted preview endpoint ran at 128K context with 8-bit quantization even though the model supports 512K. The gap between what a model can do and what a hosted endpoint serves is normal — check the endpoint's spec, not the model card's.

Who Should Care About Trinity Large?

Trinity Large matters most to teams that already wanted an open-weight model but could not use a Chinese-origin one. That is a narrower group than the launch coverage suggests, and it is a real group: defense-adjacent contractors, regulated healthcare and finance buyers, and companies whose procurement policy names model provenance.

It also matters to teams with a data-residency requirement. Self-hosting any open-weight model keeps prompts on your infrastructure, and jurisdiction of origin stops being a hypothetical when the weights sit on your own servers.

In the model-selection work we do for clients, self-hosting decisions turn on token volume far more than on benchmark scores. What we look for first is whether the workload has a steady, predictable floor. Bursty workloads almost always come out cheaper on a hosted API, because idle GPUs bill the same as busy ones.

• Good fit — a steady high-volume workload, an in-house infrastructure team, and a policy reason to avoid Chinese-origin weights.
• Good fit — teams that need to fine-tune on proprietary data without sending it to a vendor.
• Poor fit — low or spiky volume with no platform engineer to own the deployment.
• Poor fit — teams that need best-in-class reasoning today and have no license constraint. Frontier hosted models still lead on the hardest tasks.

Trinity Large vs the Other Open-Weight Options

Trinity Large's distinguishing feature is US origin under a permissive license, not a benchmark lead. Here is how the practical decision criteria line up against the open-weight models this site covers in depth.

Choose Trinity Large when model provenance is a hard requirement you have to defend to a procurement or compliance team. Choose a Chinese open-weight leader when capability per dollar is the only criterion and your policy permits it. The honest read is that Trinity Large buys you jurisdiction, not a capability edge.

What you need to run Trinity Large yourself

Trinity Large is a frontier-scale Mixture-of-Experts model, so "running it yourself" is a real infrastructure decision — not something a single laptop or gaming GPU can do. Match the path below to how seriously you need to self-host. For most teams the API or rented GPUs are the right answer; buying hardware only pays off at steady, high volume or when your data can never leave your walls.

Once Trinity Large is running, the fastest way to put it to work day to day is inside Cursor — point it at the model through OpenRouter as a custom model. And if you would rather run a model on one affordable box, see Best mini PCs for local AI and Local AI hardware calculator.

NVIDIA RTX 6000 Ada (48GB)

Power users and small clusters that want cards they own

View on Amazon →