Providers¶
janito supports multiple AI providers. This guide covers configuration for each.
For Cloudflare's OpenAI-compatible endpoint, see the
Cloudflare Workers AI setup guide (custom provider).
janito talks to models through two kinds of API:
- OpenAI-compatible APIs — the
ResponsesandCompletionsAPI types, driven by theopenaipackage. This is the default for OpenAI and for any provider or local server (LM Studio, Ollama, thecustomprovider) that exposes an OpenAI-compatible endpoint. - Native APIs — the providers' official SDKs, selectable through API
types such as
Anthropic(native Anthropic SDK),DashScope(native DashScope SDK) andGemini(native Gemini SDK). These talk directly to the provider's native API instead of its OpenAI-compatible gateway.
The API type is selected per provider with --set api-type=... (see the
Anthropic,
DashScope and
Gemini sections below).
Supported Providers¶
| Provider | Description |
|---|---|
openai |
OpenAI API |
google |
Google Gemini (Gemini models) |
custom |
Any OpenAI-compatible API (local servers, third-party) |
alibaba |
Alibaba Cloud DashScope (Qwen models) |
deepseek |
DeepSeek |
minimax |
MiniMax AI (MiniMax models) |
meta |
Meta Model API (Muse Spark models) |
xiaomi |
Xiaomi AI (Mimo models) |
moonshot |
Moonshot AI (Kimi models) |
zai |
Z.AI (GLM models) |
xai |
xAI (Grok models) |
mistral |
Mistral AI (Mistral Large models) |
anthropic |
Anthropic (Claude models) |
apertus |
Apertus (Swiss AI Initiative models via Swisscom) |
atria |
Atria (Atria-Dawn-Preview) |
opencode-go |
OpenCode Go (subscription gateway for OpenCode Go models) |
openrouter |
OpenRouter (aggregator of many models) |
Note
The provider name is always validated against this list. Whenever you pass
--provider <name> (or set provider=<name> in the config), janito checks
that it is a supported provider — one that maps to an API base URL — and
rejects unknown names with an error enumerating the supported providers.
Note
The model name is validated the same way. For providers with built-in
model entries (every provider except openrouter and custom), --model
and --set model=... accept only the provider's built-in models; an
unknown name is rejected with the available models listed. Model-scoped
settings (--set max-output-tokens=..., --set effort=..., ...)
are likewise only available for those built-in models — arbitrary model
names cannot be configured for these providers. openrouter (an
aggregator) and custom (any OpenAI-compatible endpoint) have no built-in
model list, so any model name and its settings are accepted there.
janito --list-models shows the accepted names for the active provider.
Listing providers¶
janito --show-providers prints every supported provider with its built-in
defaults — default model, API types (with the built-in default marked),
effective endpoint, masked API key, thinking/reasoning defaults, token limits
and any built-in (native) tools per API type — followed by the registered
provider variants, each marked with its base provider. The
configured default provider is flagged [active]:
Supported Providers (17):
============================================================
openai [active]
Model: gpt-6.1-sol (default)
API types: Responses (default), Completions
Endpoint: default OpenAI (no custom base URL)
API key: (not set)
Thinking: disabled
Reasoning: low (default)
Max tokens: 1,050,000 in / 128,000 out
...
alibaba
Model: qwen4-max (default)
API types: Completions, Responses (default), DashScope
Tools: code_interpreter, i2i_search, t2i_search, web_extractor, web_search (Responses)
...
alibaba-tokenplan (variant of alibaba)
Model: qwen3.8-max (configured; default qwen4-max)
...
Configured per-provider overrides (e.g. a variant's model or endpoint) are shown where set, so you can see at a glance which providers are configured and which still need a key or an endpoint.
OpenAI¶
The built-in default model is gpt-6.1-sol. An explicitly configured model
or a per-call --model selection takes precedence.
Two authentication modes are supported: a pay-as-you-go API key, or Sign in with ChatGPT (OAuth, uses your ChatGPT plan allowance instead of API billing — see Sign in with ChatGPT).
Configuration¶
# Step 1: Set provider and model
janito --set provider=openai --set model=gpt-6.1-sol
# Step 2a: Store API key (pay as you go)
janito --set-api-key="sk-your-key" --provider openai
# ...or step 2b: sign in with ChatGPT (OAuth, no API key)
janito --provider openai --login
Or interactively:
API keys and OAuth credentials are stored in
~/.janito/auth.json; the model is stored in~/.janito/config.json. janito does not readOPENAI_*environment variables. See Configuration Priority.
Popular Models¶
| Model | Description |
|---|---|
gpt-6.1-sol |
Latest flagship model (default, built-in) |
gpt-6-sol |
Previous flagship model (built-in) |
gpt-6-luna |
Fast, cost-effective model (built-in) |
gpt-6-astra |
Highest capability model (built-in) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Sign in with ChatGPT (plan allowance, no API key)¶
As an alternative to API-key billing, the openai provider supports
OpenAI's Sign in with ChatGPT flow for eligible ChatGPT plans
(official docs):
janito --login # browser sign-in, credentials stay in ~/.janito/auth.json (0600)
janito --logout # remove the ChatGPT credentials (API key untouched)
The provider is taken from -p/--provider or the configured provider; if
neither is set, OpenAI is used. For example, janito --provider openai --login
explicitly selects OpenAI.
Notes:
--loginis a no-op when the stored ChatGPT session is still fresh (it refreshes transparently when expired, and re-authenticates when the refresh token is no longer valid). Usejanito --login -fto force re-authentication even when already signed in (e.g. after a server-sidetoken_expiredrejection).--logoutreports when no ChatGPT credentials are stored and exits successfully. It removes ChatGPT credentials only; the OpenAI API key is left untouched.--loginfails when an API key is already set and no OAuth credentials exist; remove it first so billing never switches silently.- ChatGPT-plan requests use the Responses API with
store: false(the session re-sends history);--api-type Completionsis rejected with OAuth. ChatGPT-plan allowance and API billing are separate systems.
Headless or remote machines (SSH)¶
Sign-in completes through a loopback callback: janito --login starts a
temporary HTTP listener on 127.0.0.1 at a random port (fixed path
/auth/callback) and prints the authorization URL plus the exact redirect URI
it waits on:
Opening the browser for ChatGPT sign-in...
https://auth.openai.com/api/accounts/authorize?...
Waiting for callback on http://127.0.0.1:41273/auth/callback (timeout 300s).
On a machine without a browser (headless server, container, or remote host)
nothing opens automatically, and the browser's redirect to
127.0.0.1:<port> can never reach that host, so sign-in fails with
Login timed out waiting for the browser callback.
Forward that port to the machine that runs your browser, then sign in there:
- On the headless host, run
janito --loginand note thePORTin theWaiting for callback on http://127.0.0.1:PORT/auth/callbackline. - On the machine with the browser, open the tunnel (same port on both ends):
- Open the authorization URL printed by
janito --loginin the local browser and complete the sign-in.
The redirect to http://127.0.0.1:PORT/auth/callback then reaches the headless
host through the tunnel, and the credentials are stored there in
~/.janito/auth.json (0600). The callback port is chosen at runtime, so read
it from the printed line instead of reusing a previous value, and complete the
sign-in within the 300-second timeout.
Reasoning Level¶
The GPT-6 models support configurable reasoning depth via the
OpenAI-compatible reasoning_effort parameter. The supported levels are
low, medium and high; the built-in default is the standard level
(medium).
# Override the reasoning depth for a single call
janito --effort high "Your prompt"
# Set a per-provider default in the config
janito --provider openai --set effort=medium
Resolution order: --effort > per-provider config value
(--set effort=...) > the model's own default level (medium for the
GPT-6 models).
Google (Gemini)¶
Use Google Gemini models through their OpenAI-compatible API.
Get an API key: Visit Google AI Studio to create an account and generate a Gemini API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=google --set model=gemini-3.8-flash
# Step 2: Store API key
janito --set-api-key="your-gemini-api-key" --provider google
The google provider talks to Gemini through Google's OpenAI-compatibility
layer (https://generativelanguage.googleapis.com/v1beta/openai/, see the
Gemini API OpenAI compatibility docs),
so it uses the standard Chat Completions API out of the box.
Native Gemini API (optional)¶
Besides the OpenAI-compatibility layer (the Completions API type, the
built-in default), the google provider also supports the native Gemini
API through the Gemini API type. It talks to the Gemini API directly
(https://generativelanguage.googleapis.com) using the official
google-genai package:
# Install the optional package
pip install google-genai
# Use the native Gemini API for a single call
janito --api-type Gemini "Explain quantum computing"
# ...or set it as the per-provider default
janito --provider google --set api-type=Gemini
Gemini 3.x models reason by default on the native API too; reasoning depth is
controlled through --effort, sent as thinking_level. Thought
summaries stream into the reasoning panel, and function/tool calls work
exactly like the other API types (MCP included).
Popular Models¶
| Model | Description |
|---|---|
gemini-3.7-flash |
Gemini Flash model |
gemini-3.8-flash |
Latest Gemini Flash model (default, built-in) |
gemini-4-argon |
Flagship Gemini 4 reasoning model (1M unified context, up to 1M output; $2 in / $10 out per 1M intro thru Nov 30 2026) |
Model selection is restricted to the built-in models above; other Gemini
names such as gemini-2.5-pro are not accepted for this provider.
janito --list-models shows the accepted names.
Reasoning Level¶
Gemini models reason by default (thinking cannot be disabled for Gemini 3.x
models). The OpenAI-compatible reasoning_effort parameter maps to the
model's thinking_level, which accepts minimal, low, medium and
high:
# Override the reasoning depth for a single call
janito --effort high "Your prompt"
# Set a per-provider default in the config
janito --provider google --set effort=medium
Resolution order: --effort > per-provider config value
(--set effort=...) > the model's own default level (medium for
gemini-3.8-flash).
Thinking Mode¶
The google provider is Gemini-flavored: the enable_thinking
extra-body flag is not sent to Google's OpenAI-compatibility layer
(because the field does not exist and Gemini 3.x models reason by default).
Thinking depth is instead controlled through --effort, sent as
reasoning_effort (the API maps it to the model's thinking_level).
Using /thinking on or -t/--thinking is therefore a no-op for the
request body.
Example¶
# Step 1: Set provider and model
janito --set provider=google --set model=gemini-3.8-flash
# Step 2: Store API key
janito --set-api-key="your-gemini-api-key" --provider google
# Step 3: Run prompt
janito "Explain quantum computing"
Custom Providers (OpenAI-Compatible)¶
Use any OpenAI-compatible API, including local servers like LM Studio, Ollama, or third-party providers.
Configuration¶
# Step 1: Set provider, endpoint, and model
janito --set provider=custom --set endpoint="http://localhost:8000/v1" --set model="my-model"
# Step 2: Store API key (optional)
janito --set-api-key="optional-key" --provider custom
Common Endpoints¶
| Provider | Endpoint Example |
|---|---|
| LM Studio | http://localhost:1234/v1 |
| Ollama | http://localhost:11434/v1 |
| LocalAI | http://localhost:8080/v1 |
Example: LM Studio¶
# Step 1: Configure provider
janito --set provider=custom \
--set endpoint="http://localhost:1234/v1" \
--set model="local-model-name"
# Step 2: Set placeholder API key
janito --set-api-key="not-needed" --provider custom
# Step 3: Run prompt
janito "Hello"
Alibaba (Qwen)¶
Use Alibaba Cloud DashScope to access Qwen models.
Get an API key: Visit Alibaba Cloud Model Studio to create an account and generate a DashScope API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=alibaba --set model=qwen4-max
# Step 2: Store API key
janito --set-api-key="your-dashscope-api-key" --provider alibaba
Popular Models¶
| Model | Description |
|---|---|
qwen4-max |
Default model: next-gen flagship (GA 2026-11-16, MoE 2.4T/71B active, native vision) with built-in token limits, reasoning levels and tools |
qwen3.8-flash |
Fast and cost-effective, with built-in token limits, reasoning levels and tools |
qwen3.8-max |
Previous flagship model with built-in token limits, reasoning levels and tools |
qwen3.8-max-0902 |
Dated flagship snapshot, same limits/reasoning/tools as qwen3.8-max |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Reasoning Level¶
Qwen models (qwen3.8-max, qwen3.8-flash, default qwen4-max) support
configurable reasoning depth via the OpenAI-compatible reasoning_effort
parameter. The supported levels are low, medium and xhigh; the
built-in default is the standard level (medium). qwen4-max uses the
next-gen scale instead: low, high and xhigh with a built-in default
of high (medium maps to high).
# Override the reasoning depth for a single call (qwen3.8-max)
janito --model qwen3.8-max --effort medium "Your prompt"
# Set a per-provider default in the config (qwen3.8-max)
janito --provider alibaba --set model=qwen3.8-max
janito --provider alibaba --set effort=medium
Resolution order: --effort > per-provider config value
(--set effort=...) > built-in default (medium for the Qwen models).
Thinking Mode¶
Qwen models reason by default, so thinking mode is enabled out of the box for
the alibaba provider: every call sends
extra_body={'enable_thinking': True}. Pass -t / --thinking to force it
on for any provider.
Built-in Qwen models (qwen3.8-max, qwen3.8-flash, default qwen4-max)
also send extra_body={'preserve_thinking': True} on the OpenAI-compatible
Completions / Responses calls. preserve_thinking is a Qwen extension (not
an OpenAI standard parameter): it makes the API append the assistant
messages' reasoning_content to the next input in multi-turn conversations,
so the model can reference its own prior reasoning across turns. It is a
built-in model default in janito, not a configurable setting.
API Type¶
The alibaba provider defaults to the Responses API for its built-in default
model qwen4-max. The Chat Completions API remains fully supported and can
be selected per provider or per call with:
# Per provider (persisted)
janito --provider alibaba --set api-type=Completions
# Per call
janito --provider alibaba --api-type completions "Your prompt"
Built-in Tools¶
The default model qwen4-max declares built-in (native) tools —
code_interpreter, web_search and web_extractor — enabled per API type (the tools_by_api_type model-config
field); the flagship qwen3.8-max declares the same three, while qwen3.8-flash additionally
declares i2i_search and t2i_search. These are not function tools: each type is a model
capability enabled through request-body flags on the API call, so they are
always on whenever the model declares them for an API type — even with
--no-tools / an empty function-tools list (mirroring the Responses
image_generation tool for gpt-5+).
Currently they are declared for the Responses API type only: the CLI
Responses client and the web agent resolve them per
model (get_default_tools_from_provider(provider, model,
api_type="Responses")) and append them to the tools array after any
converted function-tool schemas. Note that DashScope's /responses endpoint
did not accept qwen3.8-max at the time of writing (see API Type
above), so the built-in tools are picked up automatically by the Responses
client and the web agent as soon as the endpoint supports the model. They are
left off the Completions API and the native DashScope API because the
qwen3.8-max deployment rejects code_interpreter there with
400 InternalError.Algo.InvalidParameter: The current model does not support
the code_interpreter tool.; API types not listed in tools_by_api_type send
no built-in tools (the plain tools default still applies when present).
janito --show-providers surfaces them per model, annotated with the API type
that enables them:
Native DashScope SDK (optional)¶
By default the alibaba provider talks to DashScope's OpenAI-compatible
endpoint through the Responses API (the built-in default API type for
qwen4-max; the Chat Completions API is also fully supported — see
API Type). A native DashScope SDK API type (DashScope) is
also available: it uses the official dashscope Python package against the
DashScope native API (https://dashscope-intl.aliyuncs.com/api/v1,
per-API-type endpoint, see endpoint_by_api_type).
The dashscope package is optional; janito aborts the change (with a
message naming the package) if you try to select the DashScope API type
without it:
# Install the optional package first
pip install dashscope
# Then select the native SDK API type
janito --provider alibaba --set api-type=DashScope
# Per call
janito --provider alibaba --api-type DashScope "Explain quantum computing"
Thinking mode is enabled out of the box here too: the native SDK receives
enable_thinking=True (Qwen models reason by default). The dashscope
package does not use reasoning_effort, so --effort is accepted
for parity but not mapped to a DashScope parameter.
The DashScope native API serves models from two generation endpoints:
text-generation for plain-text models and
multimodal-generation for multimodal models (Qwen-VL / Qwen-Omni, the
qwen3.x-plus generation, and the qwen3.8-max / qwen4-max flagships). janito picks
the endpoint from the model name automatically and, if the API ever rejects
the model for that endpoint (InvalidParameter: url error, please check
url), retries once on the other endpoint — so models work out of the box
here too.
Example¶
# Step 1: Set provider and model
janito --set provider=alibaba --set model=qwen4-max
# Step 2: Store API key
janito --set-api-key="your-dashscope-api-key" --provider alibaba
# Step 3: Run prompt
janito "Explain quantum computing"
DeepSeek¶
Use DeepSeek models.
Get an API key: Visit DeepSeek Platform to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=deepseek --set model=deepseek-flash
# Step 2: Store API key
janito --set-api-key="your-deepseek-api-key" --provider deepseek
API Types and Base URLs¶
The deepseek provider supports the OpenAI-compatible Responses and
Completions API types (Responses is the built-in default) against the
OpenAI-compatible base URL https://api.deepseek.com, plus a native
Anthropic SDK API type against DeepSeek's Anthropic-compatible base URL
https://api.deepseek.com/anthropic (per-API-type endpoint, see
endpoint_by_api_type).
The anthropic package is optional; janito aborts the change (with a
message naming the package) if you try to select the Anthropic API type
without it:
# Install the optional package first
pip install anthropic
# Then select the native Anthropic SDK API type
janito --provider deepseek --set api-type=Anthropic
# Per call
janito --provider deepseek --api-type Anthropic "Explain quantum computing"
Reasoning Level¶
The default model deepseek-flash supports configurable reasoning depth via
the OpenAI-compatible reasoning_effort parameter. The supported levels are
low, high and max (the API's default is high; medium/xhigh are
mapped to high for compatibility, and deepseek-v4-pro currently supports
only high/max).
# Override the reasoning depth for a single call
janito --effort max "Your prompt"
# Set a per-provider default in the config
janito --provider deepseek --set effort=high
Resolution order: --effort > per-provider config value
(--set effort=...) > built-in default (none: the API's own default
high applies).
Thinking Mode¶
DeepSeek models reason by default, so thinking mode is enabled out of the box
for the deepseek provider: every call sends
extra_body={'enable_thinking': True}. Pass -t / --thinking to force it
on for any provider.
Example¶
# Step 1: Set provider and model
janito --set provider=deepseek --set model=deepseek-flash
# Step 2: Store API key
janito --set-api-key="your-deepseek-api-key" --provider deepseek
# Step 3: Run prompt
janito "Explain quantum computing"
MiniMax¶
Use MiniMax AI to access MiniMax models.
Get an API key: Visit MiniMax Open Platform to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=minimax --set model=MiniMax-M3
# Step 2: Store API key
janito --set-api-key="your-minimax-api-key" --provider minimax
API Types and Base URLs¶
The minimax provider supports the OpenAI-compatible Completions API type
(the built-in default) against the OpenAI-compatible base URL
https://api.minimax.io/v1, plus a native Anthropic SDK API type against
MiniMax's Anthropic-compatible base URL https://api.minimax.io/anthropic
(per-API-type endpoint, see endpoint_by_api_type).
The anthropic package is optional; janito aborts the change (with a
message naming the package) if you try to select the Anthropic API type
without it:
# Install the optional package first
pip install anthropic
# Then select the native Anthropic SDK API type
janito --provider minimax --set api-type=Anthropic
# Per call
janito --provider minimax --api-type Anthropic "Explain quantum computing"
Thinking Mode¶
The default model MiniMax-M3 reasons by default. Its OpenAI-compatible API
controls thinking with a structured thinking parameter
(type can be disabled or adaptive; adaptive is equivalent to thinking
on), so janito sends extra_body={'thinking': {'type': 'adaptive'}} out of
the box. Pass -t / --thinking to force thinking on for any provider.
Popular Models¶
| Model | Description |
|---|---|
MiniMax-M3 |
Default model; reasoning by default (built-in) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Example¶
# Step 1: Set provider and model
janito --set provider=minimax --set model=MiniMax-M3
# Step 2: Store API key
janito --set-api-key="your-minimax-api-key" --provider minimax
# Step 3: Run prompt
janito "Explain quantum computing"
Meta (Muse Spark / Wonder)¶
Use Meta Model API to access Muse Spark and Muse Wonder models.
Get an API key: Visit dev.meta.ai to create an account and generate a Model API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=meta --set model=muse-spark-1.3
# Step 2: Store API key
janito --set-api-key="your-model-api-key" --provider meta
API Types and Base URLs¶
Meta Model API is drop-in compatible with the OpenAI SDK: the single base
URL https://api.meta.ai/v1 serves both the OpenAI-compatible Responses
API (the built-in default) and the Chat Completions API. The Chat
Completions API can be selected per provider or per call with:
# Per provider (persisted)
janito --provider meta --set api-type=Completions
# Per call
janito --provider meta --api-type completions "Your prompt"
Stateless Responses Handling¶
Muse Spark's Responses endpoint is handled statelessly: janito re-sends
the full conversation as typed input items on every request and never
chains with previous_response_id (per Meta's
docs, the stateless
encrypted-replay path — store: false + include:
reasoning.encrypted_content — is the recommended agentic mode and cannot
be combined with previous_response_id). Every request sends:
store: false— the server keeps no copy of the conversation;include: ["reasoning.encrypted_content"]— the chain of thought is only exposed in encrypted form; thereasoningoutput items returned in each response are replayed verbatim in the next request'sinput, preserving cross-turn reasoning for tool loops.
You can inspect the resolved mode with janito --info or /status
(Stateless Mode: stateless (client re-sends history)).
Popular Models¶
| Model | Description |
|---|---|
muse-spark-1.3 |
Default model, trained for agentic workflows (1M context, built-in) |
muse-spark-1.3-contributor |
Cheaper contributor tier of the same model |
muse-wonder-1.0 |
Frontier model, most capable for agentic tasks (1M context) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Reasoning Level¶
Muse Spark is a reasoning model: it works through a problem internally
before producing an answer. Reasoning depth is configured via the
OpenAI-compatible reasoning_effort parameter, which accepts minimal,
low, medium and high (Meta also accepts xhigh, but it maps to the
same reasoning strength as high).
# Override the reasoning depth for a single call
janito --effort high "Your prompt"
# Set a per-provider default in the config
janito --provider meta --set effort=medium
Resolution order: --effort > per-provider config value
(--set effort=...) > the built-in default (medium).
Reasoning Summaries¶
The raw chain of thought stays private, but janito requests a
human-readable summary on the Responses API
(reasoning.summary="auto", merged with reasoning.effort when set).
The summary streams as response.reasoning_summary_text deltas and is
shown in the reasoning panel (the existing on_reasoning observer). A
summary is optional: when the model does little reasoning the summary is
empty. Chat Completions has no reasoning summary.
Example¶
# Step 1: Set provider and model
janito --set provider=meta --set model=muse-spark-1.3
# Step 2: Store API key
janito --set-api-key="your-model-api-key" --provider meta
# Step 3: Run prompt
janito "Explain quantum computing"
Xiaomi (Mimo)¶
Use Xiaomi AI to access Mimo models.
Get an API key: Visit XiaoAI Open Platform to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=xiaomi --set model=mimo-v2.6-flash
# Step 2: Store API key
janito --set-api-key="your-xiaomi-api-key" --provider xiaomi
Popular Models¶
| Model | Description | Input (cache hit) | Input (cache miss) | Output |
|---|---|---|---|---|
mimo-v2.6-flash |
Fast, cost-efficient Xiaomi language model (default, built-in) | $0.0028 | $0.14 | $0.28 |
mimo-v2.6-pro |
Flagship Xiaomi language model (built-in) | $0.0036 | $0.435 | $0.87 |
mimo-v2.6-pro-ultraspeed |
mimo-v2.6-pro with up to 20x inference speed (built-in) |
$0.036 | $4.35 | $8.7 |
Prices per 1M tokens. All V2.6 models support a 1M-token context window and 128K output tokens.
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Example¶
# Step 1: Set provider and model
janito --set provider=xiaomi --set model=mimo-v2.6-flash
# Step 2: Store API key
janito --set-api-key="your-xiaomi-api-key" --provider xiaomi
# Step 3: Run prompt
janito "Explain quantum computing"
Moonshot (Kimi)¶
Use Moonshot AI to access Kimi models.
Get an API key: Visit Moonshot AI Open Platform to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=moonshot --set model=kimi-k3
# Step 2: Store API key
janito --set-api-key="your-moonshot-api-key" --provider moonshot
Popular Models¶
| Model | Description |
|---|---|
kimi-k3 |
Kimi model with configurable reasoning (default, built-in) |
kimi-k3.1-pro |
Latest Kimi K3.1 Pro model (1M context, configurable reasoning) |
kimi-k3.1-pro-highspeed |
Higher-throughput deployment of K3.1 Pro (1M context) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Reasoning Level¶
All Moonshot models (kimi-k3, kimi-k3.1-pro,
kimi-k3.1-pro-highspeed) support configurable reasoning depth via the
OpenAI-compatible reasoning_effort parameter. The supported levels are
low, high and max, and the built-in default is max (the API's own
default).
# Override the reasoning depth for a single call
janito --effort low "Your prompt"
# Set a per-provider default in the config
janito --provider moonshot --set effort=high
Resolution order: --effort > per-provider config value
(--set effort=...) > built-in default (max).
Example¶
# Step 1: Set provider and model
janito --set provider=moonshot --set model=kimi-k3
# Step 2: Store API key
janito --set-api-key="your-moonshot-api-key" --provider moonshot
# Step 3: Run prompt
janito "Explain quantum computing"
Z.AI (GLM)¶
Use Z.AI to access GLM models (Zhipu AI).
Get an API key: Visit Z.AI Open Platform to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=zai --set model=glm-5.3-flash
# Step 2: Store API key
janito --set-api-key="your-zai-api-key" --provider zai
Popular Models¶
| Model | Description |
|---|---|
glm-5.3-flash |
GLM-5.3-Flash, the fast/cheap GLM-5 model (default, built-in) |
glm-5.3-flashx |
GLM-5.3-FlashX, faster ~200 tokens/s variant (built-in) |
glm-5.3 |
Full-size GLM-5.3 model |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Example¶
# Step 1: Set provider and model
janito --set provider=zai --set model=glm-5.3-flash
# Step 2: Store API key
janito --set-api-key="your-zai-api-key" --provider zai
# Step 3: Run prompt
janito "Explain quantum computing"
xAI (Grok)¶
Use xAI to access Grok models.
Get an API key: Visit xAI Console to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=xai --set model=grok-4.6
# Step 2: Store API key
janito --set-api-key="your-xai-api-key" --provider xai
Popular Models¶
| Model | Description |
|---|---|
grok-4.6 |
Latest flagship model (default, built-in) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Example¶
# Step 1: Set provider and model
janito --set provider=xai --set model=grok-4.6
# Step 2: Store API key
janito --set-api-key="your-xai-api-key" --provider xai
# Step 3: Run prompt
janito "Explain quantum computing"
Mistral AI¶
Use Mistral AI to access Mistral Large models through their OpenAI-compatible API.
Get an API key: Visit Mistral Console to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=mistral --set model=mistral-large-4
# Step 2: Store API key
janito --set-api-key="your-mistral-api-key" --provider mistral
Popular Models¶
| Model | Description |
|---|---|
mistral-large-4 |
Latest flagship model (default, built-in; 1M context, Completions-only) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Example¶
# Step 1: Set provider and model
janito --set provider=mistral --set model=mistral-large-4
# Step 2: Store API key
janito --set-api-key="your-mistral-api-key" --provider mistral
# Step 3: Run prompt
janito "Explain quantum computing"
Anthropic (Claude)¶
Use Anthropic to access Claude models through their OpenAI-compatible API.
Get an API key: Visit Anthropic Console to create an account and generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=anthropic --set model=claude-sonnet-5-5
# Step 2: Store API key
janito --set-api-key="your-anthropic-api-key" --provider anthropic
Popular Models¶
| Model | Description |
|---|---|
claude-fable-5-2 |
Newest frontier model (1M context) |
claude-mythos-5-2 |
Limited-access frontier model, verified orgs only (1M context) |
claude-opus-5-5 |
Highest capability model (1M context) |
claude-sonnet-5-5 |
Latest flagship model (1M context; default) |
claude-haiku-5-5 |
Fastest model for high-volume, latency-sensitive tasks (1M context; 128K output) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Claude Haiku 5.5¶
Select Haiku for classification, extraction, routing, and other latency-sensitive tasks:
Official model specifications
list a 1,000,000-token context window and a 128,000-token output limit.
Haiku supports adaptive thinking with default effort medium.
Sonnet remains Janito's default Anthropic model.
Estimated prices in USD per million tokens:
| Prompt size (including cached input) | Input | Cached input (read) | Output |
|---|---|---|---|
| Up to 100,000 tokens | $0.10 | $0.01 | $0.50 |
| Over 100,000 tokens | $0.50 | $0.05 | $2.50 |
The higher tier applies to the entire request, not just tokens over the threshold. Estimates cover input, cache reads, and output; cache writes and Batch API discounts are not included.
Native Anthropic SDK (optional)¶
By default the anthropic provider talks to Anthropic's OpenAI-compatible
endpoint (https://api.anthropic.com/v1/) through the Chat Completions
API. A native Anthropic SDK API type (Anthropic) is also available: it
uses the official anthropic Python package against
https://api.anthropic.com (per-API-type endpoint, see
endpoint_by_api_type).
The anthropic package is optional; janito aborts the change (with a
message naming the package) if you try to select the Anthropic API type
without it:
# Install the optional package first
pip install anthropic
# Then select the native SDK API type
janito --provider anthropic --set api-type=Anthropic
# Per call
janito --provider anthropic --api-type Anthropic "Explain quantum computing"
Example¶
# Step 1: Set provider and model
janito --set provider=anthropic --set model=claude-sonnet-5-5
# Step 2: Store API key
janito --set-api-key="your-anthropic-api-key" --provider anthropic
# Step 3: Run prompt
janito "Explain quantum computing"
Apertus¶
Use Swisscom's OpenAI-compatible gateway to access Apertus models (Swiss AI Initiative, e.g. Apertus 1.5 70B with a 262K-token context window).
Get an API key: Visit The Keymaker to generate an API key.
Configuration¶
# Step 1: Set provider and model
janito --set provider=apertus --set model=swiss-ai/Apertus-v1.5-70B
# Step 2: Store API key
janito --set-api-key="your-apertus-api-key" --provider apertus
Popular Models¶
| Model | Description |
|---|---|
swiss-ai/Apertus-v1.5-70B |
Apertus 1.5 70B via Swisscom (default, built-in) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
Example¶
# Step 1: Set provider and model
janito --set provider=apertus --set model=swiss-ai/Apertus-v1.5-70B
# Step 2: Store API key
janito --set-api-key="your-apertus-api-key" --provider apertus
# Step 3: Run prompt
janito "Explain quantum computing"
Atria¶
Use Atria to access Atria-Dawn-Preview (256K context, text-only).
Get an API key: Visit the Atria console to create an API key (
ATRIA_API_KEY).
Configuration¶
# Step 1: Set provider and model
janito --set provider=atria --set model=Atria-Dawn-Preview
# Step 2: Store API key
janito --set-api-key="your-atria-api-key" --provider atria
Popular Models¶
| Model | Description |
|---|---|
Atria-Dawn-Preview |
Research/coding/agent model, 256K context (default, built-in) |
Model selection is restricted to the built-in models above.
janito --list-models shows the accepted names.
The Responses endpoint is stateless: janito re-sends the conversation history on every request.
Example¶
# Step 1: Set provider and model
janito --set provider=atria --set model=Atria-Dawn-Preview
# Step 2: Store API key
janito --set-api-key="your-atria-api-key" --provider atria
# Step 3: Run prompt
janito "Explain quantum computing"
OpenRouter¶
Use OpenRouter to access models from many providers (OpenAI, Anthropic, Google, Meta, DeepSeek, ...) behind a single OpenAI-compatible endpoint.
Get an API key: Visit OpenRouter Keys to create an account and generate an API key.
Configuration¶
Unlike most providers, OpenRouter has no built-in default model -- it
aggregates thousands of models, so janito cannot pick one for you. Its
provider config uses the custom placeholder as the default model, which is
not a real model name: you must supply the model explicitly, either per
call with --model or persistently in the config. As one of the two
providers without a built-in model list (custom is the other), OpenRouter
accepts any model name — the model-selection restriction that applies to
other providers (see the note at the top of this page) does not apply here:
# Step 1: Set provider and store the API key
janito --set provider=openrouter
janito --set-api-key="your-openrouter-api-key" --provider openrouter
# Step 2: Set a model (required -- no default)
janito --provider openrouter --set model=openrouter/auto
# Step 3: Run prompt
janito "Explain quantum computing"
If you try to start a session without a model, janito stops with an actionable message instead of silently sending the placeholder to the API:
Error: No model configured for provider 'openrouter'. Pass --model <name> or set it with: janito --provider openrouter --set model=<name>
You can also pass a model per call without configuring one:
OpenRouter model IDs use the vendor/model form (e.g.
openrouter/auto, anthropic/claude-3.5-sonnet, openai/gpt-4o); the
openrouter/auto route picks the cheapest available model for your prompt.
API Type¶
The openrouter provider talks to OpenRouter's OpenAI-compatible endpoint
(https://openrouter.ai/api/v1) through the standard Chat Completions
API, so its built-in API type is Completions.
OpenCode Go¶
Use OpenCode Go to access the models included in an OpenCode Go subscription. Go is part of the OpenCode Console gateway: it is a monthly plan with per-model usage limits and works from clients other than OpenCode.
Get an API key: Sign in to the OpenCode Console, subscribe to Go, and create a personal API key under Account (it starts with
oc_sk_). The key must belong to a workspace subscribed to Go.
Configuration¶
# Step 1: Set provider and (optionally) a model
janito --set provider=opencode-go --set model=glm-5.3-flash
# Step 2: Store the Console API key
janito --set-api-key="oc_sk_..." --provider opencode-go
# Step 3: Run prompt
janito "Explain quantum computing"
The built-in default model is glm-5.3-flash. Model selection is restricted
to the built-in Go catalog below; janito --list-models shows the accepted
names.
API Type and Endpoint¶
Go is served from a dedicated base URL (https://opencode.ai/inference/go),
separate from pay-as-you-go Console. janito talks to its OpenAI-compatible
Chat Completions endpoint
(https://opencode.ai/inference/go/openai/v1) through the Completions
API type. The gateway translates the request to each model's native API
(OpenAI Responses, Anthropic Messages, Gemini) when needed, so every text
model in the catalog works through the same API type.
Models¶
| Model | Context | Output | Reasoning efforts |
|---|---|---|---|
glm-5.3-flash |
1M | 128K | low, high, max (default) |
glm-5.3 |
1M | 128K | low, high, max |
glm-5.2 |
1M | 128K | high, max |
kimi-k3.1-pro |
1M | 1M | low, high, max |
kimi-k3 |
1M | 1M | max |
kimi-k2.7-code |
256K | 256K | — |
deepseek-v4.1-flash |
1M | 384K | low, high, max |
deepseek-v4-pro |
1M | 384K | high, max |
qwen3.8-max |
1M | 128K | low, medium, xhigh |
qwen3.8-flash |
1M | 128K | low, medium, xhigh |
qwen3.7-plus |
1M | 64K | — |
minimax-m3 |
1M | 128K | — |
minimax-m3.1-flash |
1M | 512K | low, medium, high, xhigh, max |
mimo-v2.6-pro |
1M | 128K | — |
mimo-v2.6-flash |
1M | 128K | — |
mimo-v2.5-pro |
1M | 128K | — |
mimo-v2.5 |
1M | 128K | — |
muse-spark-1.3-contributor |
1M | 128K | minimal, low, medium, high, xhigh |
muse-spark-1.2-contributor |
1M | 128K | minimal, low, medium, high, xhigh |
claude-haiku-5-5 |
1M | 128K | low, medium, high, xhigh, max |
gpt-6-luna |
1.05M | 128K | none, low, medium, high, xhigh, max |
gpt-5.6-luna |
1.05M | 128K | none, low, medium, high, xhigh, max |
grok-4.7 |
500K | 500K | low, medium, high, xhigh |
gemini-4-argon |
1M | 64K | low, medium, high |
longcat-2.0 |
1M | 128K | — |
step-5-preview |
1M | 64K | low, medium, high |
hy4 |
1M | 64K | none, high |
hy4-preview |
1M | 64K | none, high |
hy3 |
256K | 128K | none, low, high |
beam-free |
1M | 128K | low, medium, high, xhigh, max |
iceman-contributor-free |
256K | 128K | — |
longcat-2.5-free |
1M | 256K | — |
The catalog mirrors the Go model list and is updated as OpenCode adds or retires models. Deprecated models are not included.
Reasoning Level¶
Models that declare reasoning efforts accept --effort with the values
listed above. There is no built-in default, so the API's own default applies
unless you set one:
# Per call
janito --provider opencode-go --model glm-5.3 --effort high "Your prompt"
# Per provider/model (persisted)
janito --provider opencode-go --set effort=high
Usage Limits and Cost Estimates¶
Go usage is counted against a monthly dollar allowance per model (for
example $60 for glm-5.3-flash, $15 for glm-5.3). janito's cost
estimate uses the same token rates the gateway counts, including cache-read
rates and the context tiers some models apply above 272K (GPT Luna), 200K
(Grok 4.7), 100K (Claude Haiku 5.5), 512K (MiniMax M3) and 256K (Qwen3.7
Plus) tokens. The free models (beam-free, iceman-contributor-free,
longcat-2.5-free) estimate as $0.
Known Limitation¶
OpenCode asks third-party clients to send a stable x-opencode-session
header for routing and prompt-cache reuse. janito does not send custom
headers, so Go requests work but cannot reuse the session header's cache
hints across turns.
Provider Comparison¶
| Feature | OpenAI | Custom | Third-Party Providers |
|---|---|---|---|
| Function Calling | ✅ | Depends on API | Depends on provider |
| Streaming | ✅ | Depends on API | Depends on provider |
| Vision | ✅ | Depends on API | Depends on provider |
| Context Window | Model-dependent (built-ins list exact limits) | Varies | Varies by model |
Troubleshooting¶
Connection Errors¶
- Verify the endpoint URL is correct (including
/v1suffix) - Check firewall settings
- Ensure the server is running (for local servers)
Authentication Errors¶
- Verify your API key is correct
- Check if the API key has the necessary permissions
- Some local servers don't require an API key - try
--set-api-key="not-needed"