Arcee Trinity Large Pricing: The Three Cost Paths for a Free Model

Trinity Large is free to download. That is the honest headline, and it is also the source of most budgeting mistakes around this model.

Arcee AI publishes the weights openly, so there is no license fee and no seat cost. What you pay for instead is compute — either tokens on somebody's API, or hardware you rent or own.

This page maps the three real cost paths, including Arcee's own hosted rate card, and tells you which one fits which kind of team.

The Three Ways to Pay for Trinity Large

There are exactly three cost paths for Trinity Large: download the weights and serve them yourself, call Arcee's hosted API, or buy tokens from a third-party inference host. Each bills for something completely different.

Self-hosting bills for hardware and engineering time. The two API paths bill per million tokens, with no hardware to buy at all.

Path One: Download the Weights for Free

The weights themselves cost nothing and carry no per-use fee. Arcee publishes Trinity Large on Hugging Face, along with base, reasoning, and quantized versions of the model.

The license matters more than the price here. Arcee originally shipped Trinity under Apache 2.0, then moved the whole family — Nano, Mini, Large, and every quantized variant — to OpenMDW-1.1 after launch, in 2026.

OpenMDW-1.1 is a permissive license published through the Linux Foundation and written to cover weights and configs, not just code. Arcee states there are no field-of-use restrictions and no separate commercial license to buy.

• No license fee, no seat count, no per-token charge on the weights themselves.
• You may host, modify, post-train, and distill the model commercially under the published license terms.
• Every real cost sits downstream: GPUs, memory, power, and the person who owns the serving stack.
• Confirm the current license text on Arcee's own model card before you build on it — licenses on open models do change, as this one already has.

Path Two: Arcee's Hosted API Rate Card

Arcee publishes a hosted rate card for Trinity Large Thinking in its own documentation. As of publication it lists $0.25 per million input tokens and $0.80 per million output tokens.

Two things about that rate card deserve attention. Arcee's own launch post for the model quoted a different output rate, and the documentation lists Trinity Mini and Trinity Large Preview as not hosted at all.

That gap is not a gotcha. It is normal for a model released this recently, and it is exactly why you should price a workload against the vendor page on the day you budget it.

• The hosted endpoint is OpenAI-compatible, so most existing client code points at it with a base-URL change.
• Arcee serves the reasoning variant at a 256K context window in BF16, per its own model page.
• Reasoning models emit long outputs, and output tokens cost more than input tokens. Budget for output volume, not prompt length.
• Verify these figures on Arcee's pricing page before you commit — published rates and hosted-model availability change without notice.

Path Three: Third-Party Inference Hosts

Third-party hosts set their own prices for Trinity Large and do not have to match Arcee's. An open license means anyone can serve the model, so the same weights sell at several different rates.

OpenRouter, for example, lists the reasoning variant with its own per-million input and output prices and its own context ceiling. Those numbers sat close to Arcee's when we checked, but they moved independently.

Treat a gateway as a convenience layer, not a discount. What you gain is one API key across many models; what you lose is a single authoritative price you can plan against.

• Prices differ between hosts for the identical model — always compare on the day you buy.
• Context ceilings differ too. A host may serve a shorter window than the model natively supports.
• Check where each host runs its inference if data residency is part of your compliance story.
• Rate limits, throughput, and uptime terms come from the host, not from Arcee.

The Self-Host Cost Floor

The floor for self-hosting Trinity Large is memory capacity, and it is high. Trinity Large is a roughly 400-billion-parameter sparse mixture-of-experts model with about 13 billion parameters active per token.

Sparse activation makes the model fast to run, but every expert still has to be resident in memory. Arcee's published quantized files show the scale plainly: the 4-bit balanced build is roughly 242 GB on disk, and the 8-bit build is roughly 424 GB.

Those file sizes are the practical entry ticket. You need enough combined GPU or unified memory to hold the file, plus headroom for the key-value cache that a long context consumes.

Layer3 Labs advises businesses on the self-host-versus-API decision, and what settles it in practice is rarely the token price. The question we end up asking is whether anyone on the team will own the serving stack on a bad week. Teams without that person are buying an operations problem rather than a discount.

• Renting GPU hours converts the hardware cost into an operating cost and lets you stop paying when the job ends.
• Buying hardware only wins on steady, high-utilization workloads — an idle cluster is the most expensive way to run any model.
• Aggressive low-bit quantization shrinks the file a lot, which lowers the memory bill and lowers output quality with it.
• Electricity, cooling, and on-call engineering time are real line items that no token price includes.

Which Path Fits Your Situation

Start on a hosted API and move to self-hosting only when a specific number or rule forces the move. That order costs less and fails more cheaply than the reverse.

Almost every team overestimates how quickly self-hosting pays back. The break-even depends on sustained utilization, and most early workloads are spiky.

Use the rules below as a starting filter, then price your own token volume against a live vendor page.

• Evaluating the model or building a prototype — use the hosted API. Zero setup, and you can stop any time.
• Spiky or seasonal traffic — stay on an API. Idle GPUs bill whether or not anyone uses them.
• Data cannot leave your infrastructure — self-host. This is the one case where cost is not the deciding argument.
• Steady, heavy, predictable volume — model both paths honestly, including engineering time, before you buy hardware.
• You want a fallback if a vendor changes terms — an open-weight model gives you that regardless of which path you run today.

The Costs Nobody Puts in the Spreadsheet

The line items that break AI budgets are rarely the token rates. They are the ones that appear after the model is already in production.

Reasoning models are the clearest example. They generate long internal reasoning before answering, and you pay for those tokens on the output side.

Estimate a real workload before committing. Run a hundred representative jobs on the hosted API and measure the actual token counts rather than guessing from prompt length.

• Output token volume from a reasoning model can dwarf input volume on the same task.
• Long context is not free — a large key-value cache raises memory needs on self-hosted deployments.
• Evaluation and prompt iteration burn tokens well before launch.
• Migration cost is real if you later switch hosts, even with an identical model and an OpenAI-compatible API.

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 →