Models & providers

Setup is one API key per provider. After you add a key under LLM Providers in the dashboard, every agent on that entity can use any model from that provider without needing its own credential.

Supported providers

Local providers use the OpenAI-compatible API. You can override the base URL for any provider when you add the key.

Per-agent model selection

Each agent independently picks its model from the providers you have configured. The dashboard agent editor shows a curated dropdown of known-good models for each provider, plus a Custom field for any model ID not in the list.

The curated catalog (packages/shared/src/model-catalog.ts) records, for each model, its context window in tokens and capability flags. The runner uses the context window to decide when to compact the conversation before the window would overflow. For a custom or unlisted model, the runner falls back to a conservative 128 000-token default.

Reasoning models

Some models emit a hidden chain-of-thought (a "reasoning" or "thinking" step). Nodal-Agents handles the round-trip automatically so reasoning persists across tool-call turns:

• DeepSeek Reasoner (R1) — the runner injects thinking: { type: "enabled" } into the request body and pads any empty reasoning_content on assistant messages back to the API (the API returns HTTP 400 without it). Both transforms are applied only to requests that reach api.deepseek.com.
• OpenRouter reasoning models — the provider is configured to return reasoning_details; the runner replays them on every subsequent assistant message.
• MiniMax M3 — catalogued with the reasoning flag; handled through the MiniMax Anthropic-compatible endpoint.
• Moonshot Kimi (K2.6, K2.7 Code) — native endpoint. Both catalogued Kimi models carry the reasoning flag, so the provider injects thinking: { type: "enabled" } into their requests (and strips any conflicting reasoning_effort field, which Moonshot rejects alongside it).
• Gemini 3.x (native) — the runner injects generationConfig.thinkingConfig for gemini-3.5-flash and gemini-3.1-pro-preview, gated by the reasoning flag, so the API returns chain-of-thought across tool-call turns.
• GLM 5.2 (via OpenRouter) — catalogued with the reasoning flag; behaves like the general OpenRouter reasoning models above.

The reasoning capability flag in the model catalog gates these behaviours. Non-reasoning models are unaffected.

Reasoning effort

For models whose thinking intensity is controllable, each agent has a Reasoning setting in its edit page (Model section). The options come from the model catalog's reasoningControl declaration, so only levels the model really accepts are offered:

• Auto (default) — the provider's own default behaviour, identical to before this setting existed.
• Off — disables thinking, only offered when the model can run without it.
• Low / Medium / High / Max — the model's declared intensity scale. Each provider translates the level to its native control: OpenRouter reasoning.effort (Max maps to xhigh), OpenAI reasoning_effort, Anthropic output_config.effort on Claude ≥ 4.6 or a thinking.budget_tokens ladder on earlier models, MiniMax thinking budgets, Gemini thinking_level, Kimi K3 reasoning_effort.

Each fallback link in the failover chain can carry its own Reasoning value; a link without one inherits the agent's setting. The field is hidden entirely for models with no declared control (including custom/local models).

Capabilities by provider

Vision (image input)

Vision is not a per-provider flag — it is detected per model id. The model catalog (packages/shared/src/model-catalog.ts) keeps a VISION_MODEL_IDS set, sourced from the providers themselves (OpenRouter's /api/v1/models and models.dev), and modelCanSeeImages() looks each model up by id. A model not in the set is treated as text-only, so an inbound image is never sent to a model that can't see it.

The vision-capable model families currently in the catalog are:

• Claude — Opus, Sonnet, and Haiku (native and OpenRouter forms)
• Gemini: the 3.x preview line (3.1 Pro, 3.5 Flash, 3.1 Flash Lite via OpenRouter)
• Gemma 4 (google/gemma-4-31b-it)
• MiniMax M3
• Kimi (K2.6 and K2.7 Code, native and OpenRouter forms)
• GPT-5 and GPT-5 mini
• Mistral Large

Text-only families in the catalog include DeepSeek and GLM (z-ai/glm-5.2). Custom or unlisted model ids default to text-only.

Fallback chains

Each agent can be configured with a fallback chain: an ordered list of alternative key-and-model pairs the runner tries if the primary is unavailable (repeated 5xx errors, a timeout, or quota exhaustion). A deterministic error (like a malformed request) is not failover-worthy and propagates immediately, since a fallback provider would reject it identically. Failover is automatic and transparent to the rest of the job.

Related pages

• Getting started — how to add your first provider key
• Agents — where the per-agent model selection lives
• Connect a model — step-by-step guide for each provider type