all systems normal · status.trellisagents.example v2.3.0 · tokens pass through at $0 margin

pricing

Two meters and a pass-through. That's the whole model.

We meter orchestration (per run, volume-tiered) and guardrail checks (per thousand). Observability depth is a flat per-run adder. Model tokens pass through at provider list price with zero markup — we publish the arithmetic because you should be able to invoice-check us.

dev

$0 /mo

For building. Everything works; nothing is time-limited.

1,000 runs/month included
Sampled traces (10%, 14-day retention)
All guardrail modes, evals, CI gate
BYO model keys or prepaid token credits
Community support

Start with the quickstart

growth — usage-based

pay per run

Cross 1,000 runs in a month and you're on Growth, metered from run #1 that month. No platform minimum.

Orchestration from $0.0008/run, tiering down with volume
Guardrail checks $0.08 per 1,000
Full or forensic trace retention as adders
Tokens at provider list price, $0 margin
Unlimited seats, email support < 1 business day

Price your stack

enterprise

commit pricing

Worth discussing above ~1M runs/month, or when procurement needs paper.

Annual run commit: −20% on orchestration
SSO/SAML, SCIM, audit-log export
Customer-managed keys on forensic retention
99.99% SLA, named solutions engineer
Invoice line items split by your metadata

Talk to us

rate card

Every number we bill, on one screen.

Trellis meters

Meter	Rate
Orchestration — first 100k runs/mo	$0.0008 / run
Orchestration — next 900k runs/mo	$0.0005 / run
Orchestration — beyond 1M runs/mo	$0.0003 / run
Guardrail checks (hosted screening model)	$0.08 / 1,000 checks
Observability — sampled 10% of traces retained 14 days. Included free.	included
Observability — full 100% of traces retained 30 days.	+$0.0004 / run
Observability — forensic 100% retained 90 days, full payloads, eval snapshots.	+$0.0009 / run

Token pass-through (illustrative list prices)

Model tier	Input / M	Output / M
Economy Small fast models (8–30B class). Fine for structured, well-guarded work.	$0.15	$0.60
Frontier Flagship reasoning models. For judgment calls and open-ended synthesis.	$3.00	$15.00

Passed through at cost, invoiced line by line, cache reads metered separately. Output costs more than input everywhere in the industry because decode is sequential and prefill is parallel — we didn't invent that, we just refuse to hide it. Bring your own keys and this table leaves your invoice entirely.

three receipts

Worked examples, computed by the same code as the configurator.

Uncached worst case, assumptions printed. Change any assumption in the configurator and watch the totals move.

Support triage bot

Customer support · Economy models · Standard guardrails · Sampled traces

100,000 runs / month

tokens/run: 10,800 in + 2,100 out
model (economy): $0.00288 /run → $288.00
guardrails (2 checks): $0.00016 /run → $16.00
observability: $0 → $0.00
orchestration (tiered): $80.00
monthly total: $384.00
effective /run: $0.00384

The common starting stack. Model tokens are ~75% of the bill even on small models — which is why the configurator shows tokens first.

assumes 6 calls/run × 1,800 in + 350 out tok; $0.15/M in, $0.60/M out

Deep-research assistant

Research & analysis · Frontier models · Strict guardrails · Full traces

10,000 runs / month

tokens/run: 44,800 in + 8,400 out
model (frontier): $0.2604 /run → $2,604.00
guardrails (28 checks): $0.00224 /run → $22.40
observability: $0.00040 /run → $4.00
orchestration (tiered): $8.00
monthly total: $2,638.40
effective /run: $0.2638

Frontier research runs are ~90× the model cost of economy support runs. This is the honest reason evals matter: at these prices, an unmeasured prompt change is a budget event.

assumes 14 calls/run × 3,200 in + 600 out tok; $3.00/M in, $15.00/M out

Ops automation fleet

Ops automation · Economy models · Strict guardrails · Forensic traces

1,000,000 runs / month

tokens/run: 3,600 in + 720 out
model (economy): $0.00097 /run → $972.00
guardrails (8 checks): $0.00064 /run → $640.00
observability: $0.00090 /run → $900.00
orchestration (tiered): $530.00
monthly total: $3,042.00
effective /run: $0.00304

At small-model scale the ratio inverts: guardrails + observability + orchestration cost more than the models. That's normal — the controls are the point when agents write to production systems.

assumes 4 calls/run × 900 in + 180 out tok; $0.15/M in, $0.60/M out

Orchestration tiering: $0.0008 × first 100,000 + $0.0005 × next 900,000 + $0.0003 beyond.

honest fine print

Pricing questions, answered like engineers.

What happens when I hit a budget cap?

The run stops before the step that would exceed the cap, takes your configured fallback branch (escalate, park, or fail), and the trace records exactly where and why. Workspace-level caps hard-stop new runs and page whoever you've put on call. You will never discover a cap in an invoice.

Can I bring my own model keys?

Yes. BYO keys mean the model line disappears from our invoice entirely — you pay your provider directly and we meter only orchestration, checks, and observability. The traces and math look identical either way.

Do you charge per seat?

No. Seats are free and unlimited on every plan. We charge for runs because runs are what cost us money — seat pricing punishes you for letting more engineers read traces, which is the opposite of what we want.

Is there an annual discount?

On Enterprise, an annual run commitment cuts the orchestration fee 20% and locks the rate card for the term. Token pass-through is never discounted because it's never marked up — there's no margin to discount.

Why do output tokens cost so much more than input?

Provider economics, passed through honestly: input is processed in one parallel prefill pass, while output is generated token-by-token in a sequential decode loop. That's why output list prices run 2–10× input across the industry, and why terse system prompts don't save as much as short outputs do.

Where does prompt caching fit into these numbers?

Every worked example shows the uncached worst case. Multi-step agents typically re-send accumulated context on each call, and providers serve 60–90% of those input tokens from cache at roughly 90% off — your real model line will usually land well under the printed number. Traces meter cache reads separately so you can see your actual rate.

$ trellis estimate --honest

Price your stack before you talk to us.

The configurator does the arithmetic in the open — per-run cost at 10k, 100k, and 1M runs, assumptions stated. Bring the estimate to a demo, or don't book one at all.

Open the configurator Request a demo