Models

Nod needs a model connection to think and reply. Connect one or more services in Settings > Models, then choose the model Nod uses.

Your requests go to the service you connect. Paid providers bill you for use. To run a model on your own computer instead, see Local models.

Supported connections

Search the provider list to connect any of these services. Regional and token-plan entries use the key issued for that particular service.

Connection	Setup	Initial choice
Google Gemini	AI Studio API key	Gemini 3.8 Flash, medium effort
OpenAI / ChatGPT	API key or existing ChatGPT sign-in	GPT-6.1 Sol / GPT-6 Sol, high effort
Anthropic	API key	Claude Opus 5.5, high effort
OpenRouter	API key or browser sign-in	GPT-6.1 Sol, high effort
Google Vertex AI	Vertex API key	Gemini 4 Argon, medium effort
Amazon Bedrock	API key and Region	You choose the model and routing profile
Azure OpenAI	Endpoint, deployment, model, and API key	The deployment's model
Cloudflare Workers AI / AI Gateway	Token, account ID, and gateway ID for AI Gateway	Kimi K2.7 Code / GPT-6.1 Sol
Other named providers	Service-specific API key	A capable model from that connection
OpenAI-compatible	Server address and optional key	A model offered by the server

Other providers include Ant Ling, Baseten, Cerebras, DeepSeek, Fireworks AI, Groq, Hugging Face, Kimi Coding China, Meta, MiniMax, Mistral, Moonshot AI, NVIDIA, OpenCode Zen and Go, Qwen Token Plan, Radius, Together AI, Vercel AI Gateway, xAI, Xiaomi MiMo and token plans, and Z.AI. The picker includes their supported regional variants.

When an account model list is available, Nod loads it. For services with only a bundled catalog, Nod says Key saved and checks access on first use. Neither a catalog nor a saved key proves that your account has credit or permission to run every listed model.

You can change the initial choice. Nod preserves a working choice when you add another connection. It uses the recommended model when available, otherwise the first supported model in that connection's catalog. For Google Gemini, you must choose a model if Gemini 3.8 Flash is unavailable. When Bedrock offers several models or profiles, you must also choose because profiles can change where requests are processed.

Google does not permit third-party assistants to reuse Gemini CLI OAuth. A Gemini app subscription is not a Nod sign-in option. Anthropic's authentication conditions also require an API connection for Claude in Nod.

Connect a service

Select Settings at the bottom of the sidebar, then Models. Search for a service or select a common provider. Onboarding shows the same options before your first chat.

If a key has a recognizable format for a different provider, Nod shows the mismatch beside the key field before sending or saving it. Choose the matching provider or paste that provider's key. Unfamiliar formats still use the provider's normal connection checks; a matching format alone does not prove a key works.

Select your current model to open Choose a model. Search by model or provider, then select a model for your next message. Recommended choices appear first, and a check marks your current choice. Reads images identifies models that can view images directly; Extra thinking identifies models that can think before replying. Capabilities shared by every available model appear once above the list. During onboarding, More providers opens the full list to browse or search.

If a connection stops working, its row in Settings > Models says what it needs: Reconnect a sign-in, or remove a key or server connection and add it again. When it's the connection you selected, chat links to that screen.

To change to an available model, you can also tell Nod which model and service to use. This works in Nod, Telegram, and WhatsApp. Nod changes the saved selection for the next turn. Connecting a new service or signing in again still needs the private flow in the app.

Next to OpenAI, select Add API key.
Paste your key into OpenAI API key, then select Save connection.

Next to OpenAI, select Sign in with ChatGPT.
Sign in to ChatGPT in the browser tab that opens, and allow Nod to use your ChatGPT plan.
Return to Nod. If the browser ends on a page that doesn't load, copy its full address into Callback URL and select Complete sign-in.

Nod uses OpenAI's Sign in with ChatGPT for open-source and locally hosted apps. Requests go to the OpenAI API and use your plan's included usage. ChatGPT lists Nod under Settings → Usage, where you can see and limit its usage or disconnect it. It needs ChatGPT Plus or Pro. On other plans, OpenAI's consent page says a required permission isn't available, and the sign-in fails. In a workspace your organization manages, an admin has to allow third-party apps first, or OpenAI says your organization hasn't enabled access for this app. Otherwise, connect an OpenAI API key instead.

ChatGPT sign-in listens on port 1455 where Nod's server runs. If another program uses that port, Nod stops with an error before it opens OpenAI. When connecting to a remote server, the final browser address may not load on your device. Copy that full address into Callback URL in Nod and select Complete sign-in. The server checks the sign-in and stores the connection; you do not need to expose port 1455 publicly.

Next to OpenRouter, select Sign in to have OpenRouter create a key for Nod in your browser, or Add API key to paste a key.
Finish the sign-in, or select Save connection for a key.

Nod lists the OpenRouter models that support text and tools.

The openrouter/free and openrouter/auto routers can select different models for each request. Nod keeps your router choice and uses an 8,192-token working limit. This leaves room for routes with a small context window. Provider limits and free-model availability still apply.

In the Amazon Bedrock console, create a long-term key under API keys. Short-term keys expire within hours.
In Nod, next to Amazon Bedrock, select Add API key.
Enter the Region your models run in, such as us-east-1, and paste the key into Amazon Bedrock API key.
Select Save connection, then choose a model.

Nod lists the models and inference profiles Bedrock offers in that Region, such as eu.anthropic.claude-opus-5-5. The key still needs permission to call the one you choose. A profile that starts with global. can send requests to any commercial AWS Region. A geographic profile such as eu. or us. stays in that geography, and each model's page in the AWS docs lists the Regions it can use. That's why Nod doesn't choose a Bedrock model for you.

The key needs to list models (bedrock:ListFoundationModels and bedrock:ListInferenceProfiles) and call them. Keys made in the Bedrock console get the AmazonBedrockLimitedAccess policy, which allows both. Nod doesn't use AWS access keys or profiles.

In Azure AI Foundry, open your model deployment and copy its endpoint, deployment name and key.
In Nod, next to Azure OpenAI, select Add API key.
Enter the Endpoint, such as https://your-resource.openai.azure.com, and the Deployment name. If the deployment has its model's name, Nod fills in Model. Otherwise, choose the model the deployment runs.
Paste the key into Azure OpenAI API key, then select Save connection.

Nod uses Azure's v1 API at that endpoint and sends the key only there. The endpoint needs HTTPS, unless it uses a loopback address on Nod's server. An address that ends at the resource or at /openai gets /openai/v1 added. Any other path, such as an API gateway, is used as you enter it.

Each deployment is one connection with one model. Add another connection for each deployment you want to use. The model you choose sets the context size and the prices Nod counts toward your spending. Microsoft Entra ID sign-in isn't supported.

Next to OpenAI-compatible, select Add server.
Check the Server address. Nod fills in Ollama's address, http://localhost:11434/v1. Add an API key only if the server needs one.
Select Save connection.

Use this for Ollama, LM Studio, vLLM, llama.cpp and hosted services with an OpenAI-compatible API. See Local models for server setup and what changes.

Switch and manage connections

All the models from your connections appear in one searchable list. Choosing a model also chooses the connection that pays for it.

OpenRouter models show input and output token prices beside each model name, in USD per million tokens. Prices can wrap to the next line on small screens. The list identifies free tokens and prices that vary by model. These are the rates from the last model list update. Actual charges can vary with routing, caching, context length, and extra services. To update prices, refresh the OpenRouter connection in Models. See OpenRouter's model pricing.

You can connect several accounts of one service, such as two ChatGPT accounts or a personal and a work API key. A ChatGPT connection shows the account's email. A key connection, including one an OpenRouter sign-in created, shows the key's last four characters, which the model never sees. Signing in again with an account you already connected, or adding the same key or server address to the same service again, updates that connection instead of adding another.

If your selected connection is removed or needs reconnecting, the next connection you add or reconnect in Models becomes your model. If only your model disappears from a working connection, Nod keeps your choice and asks you to choose another. Nod doesn't switch by itself after a failed request.

To	Do this
Switch model	Open Settings → Models, then pick a model.
Update a model list	In Models, select the refresh button next to the connection.
Fix a broken connection	Do what its row says: Reconnect a sign-in, or remove a key or server connection and add it again.
Remove a connection	Select the remove button next to it. If it was selected, choose a new model.

One model for everything

Nod uses the same model choice in the app, Telegram and WhatsApp. A task that's already running keeps the model it started with. An audio model's Text support label names its companion from the same connection. Requests without recordings use that companion; follow-ups that still include recordings use the audio model. Your saved model choice stays unchanged.

If a model request fails, Nod doesn't switch to another connection. It retries a temporary provider error, such as an overload or rate limit, up to three times.

Background work, such as memory upkeep, uses a smaller model from the same connection when it has one, such as gpt-6-luna or claude-haiku-5-5. Otherwise it uses your model or, for an audio model, its text companion. Background work and checks use the lightest reasoning their model offers: off, minimal, low or medium in that order, or the model's first effort level if it offers none of these.

Models with a small context window

For a context window below 65,536 tokens, Nod uses short instructions and loads one detailed tool at a time. It reads guides, saved memory and older messages when needed. Large tool results stay in workspace files, with a short preview in the conversation.

Nod reserves space for the reply and starts history compaction earlier. It keeps your current request and rules complete. If a request still does not fit, Nod asks for a shorter request or a model with a larger context window. Large images and tool schemas can need a larger window. Token estimates cannot guarantee that every provider accepts a request.

The same server checks still decide app actions, sign-ins and payments. A smaller context window does not change those checks. Model ability still affects whether Nod can complete a task.

Decision checks

Two checks can use a decision model: reading whether your reply to a confirmation approves it, and checking whether an email Nod reads through your apps gives access to an account. Without a decision model, the email check uses your connection's smaller background model. Your selected model, or its visible text companion for an audio model, decides whether an action can run and writes and fact-checks confirmation questions. This choice is made before the request; a failed check never switches models.

Pick a capable model if Nod acts for you: the trust check runs on it or its text companion. Use the decision evals to compare models on synthetic permission checks before changing the model you rely on.

Current connection	Confirmation replies
OpenAI API key	GPT Decisions (`gpt-6-luna`) with the same key
OpenRouter	Jev (`typesafe/jev-1.13`) with the same OpenRouter key
Every other connection	Your selected model or its text companion

These calls are billed through the connection that runs them. GPT Decisions is paid API use, separate from a ChatGPT subscription. OpenRouter sends the checks to TypeSafe, even when you selected a chat model from another provider. See OpenAI Decisions and Jev on OpenRouter.

In a source install or self-hosted server, set TYPESAFE_API_KEY in .env to use Jev directly (jev-1.13.0) for these checks. The key selects TypeSafe regardless of your chat connection. Remove it to use the connection rules above, then apply the configuration change. The key stays on the server and is not added to Models.

A failed decision request does not switch providers or approve anything: the confirmation stays pending, and your reply reaches Nod as an ordinary message. A failed email check hides that email's content. See Approvals and the trust check.

Set connections in server settings

In a source install or self-hosted server, you can add connections in .env. They show Server settings in Models. Update their values in .env, then apply the configuration change.

Removing an API key removes its server-managed connection. For an OpenAI-compatible server, remove OPENAI_COMPATIBLE_BASE_URL instead. Connections saved through the app stay intact. If you removed the selected connection, choose another model in Models.

Every service below supports environment setup. You can add several provider keys at once. Set LLM_PROVIDER to the provider ID for your initial model choice. Leave LLM_MODEL empty for the provider's default, or set an exact model ID from its list. A model you choose in the app takes priority. ChatGPT subscriptions still need browser sign-in in Models.

Provider ID	Service	Key variable
`openai`	OpenAI	`OPENAI_API_KEY`
`anthropic`	Anthropic	`ANTHROPIC_API_KEY`
`google`	Google Gemini	`GEMINI_API_KEY`
`openrouter`	OpenRouter	`OPENROUTER_API_KEY`
`amazon-bedrock`	Amazon Bedrock	`AWS_BEARER_TOKEN_BEDROCK`
`google-vertex`	Google Vertex AI	`GOOGLE_CLOUD_API_KEY`
`azure`	Azure OpenAI	`AZURE_OPENAI_API_KEY`
`ant-ling`	Ant Ling	`ANT_LING_API_KEY`
`baseten`	Baseten	`BASETEN_API_KEY`
`cerebras`	Cerebras	`CEREBRAS_API_KEY`
`cloudflare-workers-ai`	Cloudflare Workers AI	`CLOUDFLARE_WORKERS_AI_API_KEY`
`cloudflare-ai-gateway`	Cloudflare AI Gateway	`CLOUDFLARE_AI_GATEWAY_API_KEY`
`deepseek`	DeepSeek	`DEEPSEEK_API_KEY`
`fireworks`	Fireworks AI	`FIREWORKS_API_KEY`
`groq`	Groq	`GROQ_API_KEY`
`huggingface`	Hugging Face	`HF_TOKEN`
`kimi-coding`	Kimi Coding China	`KIMI_API_KEY`
`meta`	Meta	`META_API_KEY`
`minimax`	MiniMax	`MINIMAX_API_KEY`
`minimax-cn`	MiniMax China	`MINIMAX_CN_API_KEY`
`mistral`	Mistral	`MISTRAL_API_KEY`
`moonshotai`	Moonshot AI	`MOONSHOT_API_KEY`
`moonshotai-cn`	Moonshot AI China	`MOONSHOT_CN_API_KEY`
`nvidia`	NVIDIA	`NVIDIA_API_KEY`
`opencode`	OpenCode Zen	`OPENCODE_API_KEY`
`opencode-go`	OpenCode Go	`OPENCODE_GO_API_KEY`
`qwen-token-plan`	Qwen Token Plan	`QWEN_TOKEN_PLAN_API_KEY`
`qwen-token-plan-cn`	Qwen Token Plan China	`QWEN_TOKEN_PLAN_CN_API_KEY`
`qwen-token-plan-individual`	Qwen Token Plan Individual	`QWEN_TOKEN_PLAN_INDIVIDUAL_API_KEY`
`radius`	Radius	`RADIUS_API_KEY`
`together`	Together AI	`TOGETHER_API_KEY`
`vercel-ai-gateway`	Vercel AI Gateway	`AI_GATEWAY_API_KEY`
`xai`	xAI	`XAI_API_KEY`
`xiaomi`	Xiaomi MiMo	`XIAOMI_API_KEY`
`xiaomi-token-plan-ams`	Xiaomi Token Plan Amsterdam	`XIAOMI_TOKEN_PLAN_AMS_API_KEY`
`xiaomi-token-plan-cn`	Xiaomi Token Plan China	`XIAOMI_TOKEN_PLAN_CN_API_KEY`
`xiaomi-token-plan-sgp`	Xiaomi Token Plan Singapore	`XIAOMI_TOKEN_PLAN_SGP_API_KEY`
`zai`	Z.AI	`ZAI_API_KEY`
`zai-coding-cn`	Z.AI Coding China	`ZAI_CODING_CN_API_KEY`

Additional settings:

Service	Settings
Anthropic	`ANTHROPIC_WORKSPACE_ID`, required for organization keys that aren't limited to one workspace. Leave empty for keys limited to one workspace.
Amazon Bedrock	`AWS_REGION`, such as `us-east-1`. Set `LLM_MODEL` to select a model or inference profile when several are available.
Azure OpenAI	`AZURE_OPENAI_ENDPOINT` and `AZURE_OPENAI_MODEL`, the model ID your deployment runs. Set `AZURE_OPENAI_DEPLOYMENT` if the deployment has a different name.
Cloudflare	`CLOUDFLARE_ACCOUNT_ID`, the 32-character hexadecimal account ID. AI Gateway also requires `CLOUDFLARE_GATEWAY_ID`.
OpenAI-compatible	`OPENAI_COMPATIBLE_BASE_URL` and optional `OPENAI_COMPATIBLE_API_KEY`. Use `LLM_PROVIDER=compatible` for the initial choice.

Set the cloud provider's required fields before starting Nod. A Cloudflare gateway ID has one to 64 lowercase letters, digits, or hyphens, starting with a letter or digit. Both Cloudflare connections use the same account ID from .env; connections saved in Models can use separate accounts and gateways.

For Azure, leave LLM_MODEL empty to use the deployment's model, or set it to the same model ID as AZURE_OPENAI_MODEL. The deployment name defaults to that ID. The Azure setup rules for endpoints also apply to .env.

LLM_PROVIDER=google
GEMINI_API_KEY=<your-key>

Regional providers use separate key variables so one region's key isn't automatically sent to another region. These connections don't inherit host-wide AWS profiles or Google service account files.

Where your keys go

The Nod server adds your key to each model request. The key never enters the workspace, Nod's browser or the model's context.

flowchart LR
  you([You]):::accent --> server[Nod server]
  store[(Encrypted<br/>key store)]:::muted -- key --> server
  server -- request + key --> provider[Model provider]:::accent
  provider -- reply --> server
  server -- reply --> chat[Chat]
  sandbox[Workspace<br/>and browser]:::muted
  server -. no key .-> sandbox

Nod encrypts saved keys and sign-ins with the Vault key. macOS uses Keychain, the Windows app uses Windows DPAPI, and Linux source installs use a private file. The self-hosting stack generates NOD_VAULT_KEY in its private .env. See Vault configuration.
Nod checks credential storage before starting a connection. If storage is unavailable, check the Vault configuration, permissions and database connection, then try again.
Keys from .env stay in server memory and aren't copied into the database.
Each key goes only to its own service: Amazon Bedrock in the Region you entered, Google Vertex AI, or the Azure OpenAI endpoint you entered.
Your browser doesn't store the key, and Nod removes it from provider errors.

Images with a text model

If your selected model cannot read images, Nod looks for an image model in your connected services. It checks your selected connection first, then your other connected services. When one is available, it receives your current request and the images. Your selected chat model receives its description and stays selected. This image request uses that service's credentials and counts toward your spending limits. If no image model is available, the files stay in the workspace. See Files and voice messages.