Skip to content
Arcee AI

Trinity Large Thinking

Trinity Large Thinking is a reasoning-focused variant in Arcee AI's Trinity Large family: a 398B-parameter sparse mixture-of-experts model with about 13B active parameters per token, built on Trinity Large Base and emphasizing extended chain-of-thought reasoning.

View API reference
Input and output price
Input $0.25, Output $0.90, Per 1M tokens
24h uptime
Loading AI Gateway uptime
Get API keyRead the docs
import { streamText } from 'ai'


const result = streamText({
  model: 'arcee-ai/trinity-large-thinking',
  prompt: 'Why is the sky blue?'
})
Read docs

Copy link to headingPlayground

Try out Trinity Large Thinking by Arcee AI. Usage is billed to your team at API rates. Free users (those who haven't made a payment) get $5 of credits every 30 days.

arcee-ai logo
arcee-ai logo

Trinity Large Thinking

Copy link to headingProviders

Route requests across multiple providers. Copy a provider slug to set your preference. Visit the docs for more info. Using a provider means you agree to their terms, listed under Legal.

Provider
Context
Max Output
Latency
Throughput
Input
Output
Cache
Web Search
Capabilities
ZDR
No Training
Free Tier
Release Date
Arcee AI
Legal:Terms•Privacy
262K80K0.4 s387 tps
$0.25/M
$0.90/M
—
04/01/2026

Copy link to headingUptime

Direct request success rate on AI Gateway and per-provider. Visit the docs for more info.

Copy link to headingThroughput

P50 throughput on live AI Gateway traffic, in tokens per second (TPS). Visit the docs for more info.

Copy link to headingLatency

P50 time to first token (TTFT) on live AI Gateway traffic, in milliseconds. View the docs for more info.

Getting started

Call Trinity Large Thinking through AI Gateway with the AI SDK generateText and streamText functions, or through the OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs by changing the base URL. AI Gateway authenticates the request and routes it to an available provider.

Install the AI SDK (pnpm add ai dotenv), create an API key from the API Keys page, and set it as AI_GATEWAY_API_KEY in your environment. Full setup is covered in the text generation quickstart.

index.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'arcee-ai/trinity-large-thinking',
    prompt: 'Why is the sky blue?',
  });


  console.log(result.text);
}


main().catch(console.error);

Top-level parameters

The same Trinity Large Thinking request in each API format AI Gateway supports.

top-level-params.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'arcee-ai/trinity-large-thinking',
    system: 'You are a concise technical assistant.',
    prompt: 'Summarize the tradeoffs between static generation and SSR.',
    maxOutputTokens: 1024,
  });


  console.log(result.text);
}


main().catch(console.error);

Standard parameters like prompt, messages, temperature, and tools work as documented in the AI SDK docs. These are the parameters with model-specific behavior.

ParameterTypeRequiredDescription
modelstringYesModel ID in the form creator/model, e.g. arcee-ai/trinity-large-thinking. AI Gateway routes the request to an available provider.
maxOutputTokensnumberNoHard cap on generated tokens. Trinity Large Thinking supports up to 80,000 output tokens. Reasoning tokens count toward this limit.
reasoning'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'NoProvider-agnostic reasoning effort, available in AI SDK 7 or later. Maps to the provider’s native reasoning configuration; reasoning settings under providerOptions take precedence when both are set. See the Reasoning section below.
providerOptionsRecord<string, JSONValue>NoAI Gateway routing options under gateway, plus any provider-native options under the provider’s own namespace — see the table below.

Input limits

InputFormatsSourcesMax countMax sizeLimits
Text————Prompt and response share the 262K-token context window

Provider options

Set AI Gateway routing options under providerOptions.gateway. For provider-specific options, pass them under the provider’s namespace as documented by the AI SDK.

Learn more in the AI SDK provider docs.

provider-options.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'arcee-ai/trinity-large-thinking',
    prompt: 'Why is the sky blue?',
    providerOptions: {
      gateway: {
        only: ['arcee-ai'],
      },
    },
  });


  console.log(result.text);
}


main().catch(console.error);

These AI Gateway routing options apply to every model. Provider-specific options pass through under the provider’s own namespace (for example providerOptions.anthropic) exactly as documented by the AI SDK.

ParameterTypeRequiredDescription
providerOptions.gateway.onlystring[]NoRestrict routing to these provider slugs. Requests fail over only within the listed providers.
providerOptions.gateway.orderstring[]NoPreferred provider order. Listed providers are tried first; unlisted providers remain available as fallbacks.
providerOptions.gateway.sort'cost' | 'ttft' | 'tps'NoRank candidate providers by price, time to first token, or tokens per second instead of the default routing order.
providerOptions.gateway.zeroDataRetentionbooleanNoRoute only to providers with a zero-data-retention policy for this model.

Routing across providers

AI Gateway serves the same model through multiple providers and fails over automatically. order expresses a preference while keeping every provider eligible; only is a hard allowlist — if none of the listed providers are available the request fails instead of falling back.

Options under a provider's own namespace (for example providerOptions.anthropic) are forwarded to that provider with the request. Providers ignore option namespaces that don't apply to them, so it is safe to set provider options alongside gateway routing options.

Reasoning

AI Gateway bridges reasoning across every API format. The AI SDK exposes a provider-agnostic top-level reasoning level (none, minimal, low, medium, high, or xhigh); the Chat Completions and Responses formats take the same effort under reasoning.effort; and the Anthropic Messages format uses a native thinking token budget. Whichever you send, the gateway maps it to the target model’s native configuration, converting between effort levels and token budgets as needed. Reasoning-related settings under providerOptions take full precedence over the top-level reasoning value and are never merged. Reasoning tokens typically count toward your output-token usage, though how they’re reported and billed varies by provider.

Learn more in the AI Gateway reasoning guide.

reasoning.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'arcee-ai/trinity-large-thinking',
    prompt: 'Explain the Monty Hall problem step by step.',
    reasoning: 'high',
  });


  console.log(result.text);
}


main().catch(console.error);

Tool calling

Expose tools the model can call. Define each tool’s inputs with a Zod schema.

tool-calling.ts
import { generateText, tool } from 'ai';
import { z } from 'zod';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'arcee-ai/trinity-large-thinking',
    prompt: 'What is the weather in San Francisco?',
    tools: {
      getWeather: tool({
        description: 'Get the current weather for a location',
        inputSchema: z.object({ location: z.string() }),
        execute: async ({ location }) => ({ location, temperatureC: 18 }),
      }),
    },
  });


  console.log(result.text);
}


main().catch(console.error);

Copy link to headingAbout Trinity Large Thinking

Trinity Large Thinking is a 398B-parameter sparse mixture-of-experts model with about 13B active parameters per token. It is built on Trinity Large Base and emits intermediate reasoning in the output when the task calls for it.

Use it when you need audit-friendly, stepwise reasoning more than the shortest possible reply. Choose Trinity Large Preview when you do not need trace-heavy output.

Check https://docs.arcee.ai/language-models/trinity-large-thinking for the latest capabilities, limits, and rates. Reasoning depth trades off against speed and token count, so validate latency and cost on your prompts before you commit to architecture.

Copy link to headingWhat To Consider When Choosing a Provider

  • Configuration: Reasoning traces add output tokens. Budget for longer completions, stream responses, and compare $0.25 per million input tokens and $0.9 per million output tokens to your cost model.
  • Zero Data Retention: Zero Data Retention is offered on a per-provider and model basis. See the documentation for details.
  • Authentication: AI Gateway authenticates requests using an API key or OIDC token. You do not need to manage provider credentials directly.

Copy link to headingWhen to Use Trinity Large Thinking

Best for

  • Auditable enterprise workflows: Step-by-step reasoning you can log and review
  • Analytical error reduction: Tasks where visible intermediate steps lower error rates
  • Traceable code review: Debugging or refactoring where the model's steps run alongside your own review
  • Inspectable decision flows: Multi-step pipelines where each stage must be reviewable

Consider alternatives when

  • Short single-turn replies: Trinity Large Preview answers faster with fewer tokens
  • Minimal output budget: Reasoning traces add tokens that may not fit your cost model
  • Cost-dominant workloads: Trinity Mini meets a lower price point when its quality bar is enough

Copy link to headingConclusion

Trinity Large Thinking adds trace-oriented, post-trained reasoning on top of Arcee AI's Trinity Large Base stack in AI Gateway. Choose it when auditable steps matter; choose Trinity Large Preview when you do not need that overhead.

Copy link to headingFrequently Asked Questions

  • What's the difference between Trinity Large Thinking and Trinity Large Preview?

    Thinking emits extended chain-of-thought reasoning; Preview does not emphasize trace output. Thinking runs as a 398B sparse MoE with about 13B active parameters per token. Preview is a 400B-parameter (13B active) MoE aimed at long-context reasoning workloads. Choose Thinking when you need explicit reasoning traces; choose Preview when you do not.

  • Does chain-of-thought reasoning affect token usage?

    Yes. Intermediate steps count in the output, so expect higher token use than a short answer from the base preview model. Factor that into cost and latency planning.

  • When should I use this instead of Trinity Mini?

    When you need large-stack reasoning traces more than Mini's cost profile. Trinity Mini uses 26B total parameters with 3B active and fits high-volume, budget-sensitive inference. Trinity Large Thinking fits heavier reasoning and audit-style review, not minimal token use.

  • Do I need an Arcee AI account to access Trinity Large Thinking on AI Gateway?

    No. Use your AI Gateway API key or an OIDC token. You don't need a separate provider account.

  • Can I use Trinity Large Thinking with the AI SDK?

    Yes. Set model to arcee-ai/trinity-large-thinking in the AI SDK's streamText or generateText call. AI Gateway also exposes OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and OpenResponses-compatible interfaces.

  • Is the reasoning trace useful for compliance or audit purposes?

    It can help. The model can surface intermediate steps you log next to the final answer. You still own retention, access control, and policy for those logs.

  • Does AI Gateway provide observability for Trinity Large Thinking requests?

    Yes. Token usage, latency, and cost show in your AI Gateway dashboard for each request without extra instrumentation.

Your use is subject to Arcee AI's Terms & Privacy Policies.