A local-first multi-agent app development platform, built on PenguinHarness
title: Models & Providers description: Add models to a Project, set API keys and the default model, and choose thinking levels and fast mode.
Each Project has its own model table: the models its conversations can use, grouped by provider, with their credentials, limits, and prices. You manage the table on the Models page. An agent is never tied to a model; the model is chosen when a conversation starts.
- To find your way around, see The Models page.
- To add models, see Add a model group, Add a model, or Create a model group with AI.
- To give models credentials, see Set API keys.
- To choose which model new conversations use, see Set the default model.
- To tune requests, see Thinking levels and Fast mode.
- For the full list of built-in providers and the file format, see Built-in provider groups and The per-Project model table.
The Models page
In the sidebar, select Models. Models are listed in groups, one per provider.
- Groups. Built-in groups follow the order in Built-in provider groups. Groups you create follow them, sorted by name. A built-in group with no models is hidden; Custom is always shown.
- Open and close groups. Select a group's header to open or close it. On your first visit only the TokenDance group is open. The browser remembers which groups you opened, per Project.
- Reorder groups. Drag a group's header to move it. The order is saved in this browser, per Project, and the model picker in the chat uses the same order. Dragging is not available on touch screens or while searching.
- Search. Type in Search models: id / name / provider to show only the matching models. While you search, every matching group is open.
Each model card shows the model's display name, tags, context window, prices, key status, and the Tokens the model has used so far.
| Tag | Meaning |
|---|---|
| Default | The Project's default model |
| Vision | The model accepts images |
| Proxy vision | The model reads images for models without vision |
| Video | The model accepts videos |
| Fast | Fast mode is on |
| Free | All three prices are 0 |
| N% off | A promotion or an off-peak rate currently applies; see Prices and promotions |
Prices are shown per million Tokens, in the order cache read / cache write / output. The currency is the one chosen under Currency in the settings: USD $ or CNY ¥, converted at a fixed rate of 7.
Select a card to open Model settings. It links to the provider's model list (Get model IDs), to the model's own page (Model page) and, like the Enter key dialog, to the provider's key console (Manage keys).
A group's header shows the provider's logo, the group's name, its model count and an arrow that turns when the group opens. On the right it holds, from left to right:
- the group's balance, for TokenDance and DeepSeek once the group has a key, with a pin and a refresh icon before it and a divider after it; see Account balances;
- whether the group is connected, and Connect, for TokenDance, Penguin Go and ModelScope; see Connect an account;
- Enter key, on every group but Custom; see Set API keys;
- the speed test; see Measure speed;
- Add model, on Custom, vLLM and groups you created; see Add a model.
While the TokenDance group has no key, a banner above the groups offers to connect your TokenDance wallet, so the models there need no key set by hand. Its Connect runs the same flow as the group's. Select × to hide the banner in this browser.
Only the Project owner can change models and credentials. Members can search, open and close groups, reorder them in their own browser, see balances and connection status, and open Model settings read-only.
Add a model group
A group you create works like the Custom group: its models use one of the generic protocols, and each carries its own base URL.
- On the Models page, select Create manually, or select Add group (+) below the last group. The Add group dialog opens.
- In Group name, enter a name. The name:
- starts with a lowercase letter or digit;
- uses only lowercase letters, digits,
-and_; - is at most 32 characters long;
- cannot match a built-in group or an existing group.
- Choose Create only or Import models, then follow the section below for your choice.
Create an empty group
- Select Create only, then select Confirm. The Add model dialog opens for the new group.
- Add the first model; see Add a model.
The group appears in the list once its first model is saved.
Import models from an endpoint
Import models fills a new group with every model an OpenAI-compatible or Anthropic-compatible endpoint lists.
- Select Import models.
- In API key, enter the endpoint's key. The server's
OPENAI_*/ANTHROPIC_*variables are not used for an endpoint that is not the vendor's own (see Set API keys), so a listing without a key is refused. - In Custom base URL, enter the endpoint's base URL.
- Select Detect at the top-right of the field, or pick the protocol from the menu at the right edge of the field. See Detect a custom model's protocol.
- Select Import all models. Adelie asks the endpoint for its model list and saves every model into the new group, in the endpoint's order.
Each imported model gets the base URL, the protocol, and the key you entered. Only the model id comes from the endpoint: prices, context window, and display name stay empty, and vision stays off until you detect it or turn it on. That is the same starting point as a model you add by hand.
Some ids are skipped, and the result says how many: "Imported {added} models, skipped {skipped} entries". An id is skipped when it is empty, longer than 200 characters, contains control characters, or is already taken.
If the protocol cannot list models ("This protocol cannot list models — add them manually") or the list is empty, nothing is saved and the dialog stays open. A failed detection only turns the protocol suffix amber; you can still pick the protocol by hand or switch back to Create only.
The listing uses POST /api/projects/:id/models/list (owner only), which calls AgentHub's listModels() on that protocol's client with a 20-second limit.
Delete a group
- On the header of a group you created, select Delete group.
- Confirm the deletion.
All of the group's models and their API keys are removed. Built-in groups cannot be deleted.
Add a model
Add model is on the headers of Custom, vLLM and the groups you created. The other built-in groups — the vendors and the gateways — carry their built-in models only; see Built-in models only.
- On the group's header, select Add model.
- In Model ID, enter the model id exactly as the provider's API expects it, for example
qwen3-32b. Get model IDs opens the provider's model list. - Optional: in Display name, enter a display name. An empty display name shows the model id.
- Fill in the credentials and endpoint:
- API key: required — these groups point at endpoints that are not a vendor's own, and no environment variable is used for such an endpoint.
- Custom base URL: required. Enter your server's or gateway's endpoint.
- Optional: fill in the limits and prices:
- Context window: the model's context window in Tokens. For a model that is not in the built-in catalog, an empty field saves as 1000000.
- Max output tokens: the most output Tokens per request. Leave it empty to use the agent's setting; lower it for models with a small context.
- Cache read price, Cache write price, and Output price: per million Tokens, in the display currency; they are stored in USD. Fill in all three or none.
- Optional: turn on Vision support if the model accepts images, or select Detect; see Detect vision support. New models in Custom and in groups you created start with vision off; models you add to vLLM start with it on.
- Optional: turn on Fast mode; see Fast mode.
- Select Confirm.
Which protocol a new model uses depends on its group:
- vLLM always uses
openai-chat-vllm-adapter. - Custom and groups you created: pick the protocol from the base URL field, or detect it. See Detect a custom model's protocol.
Built-in models only
Every built-in group except Custom and vLLM carries the models in Adelie's built-in catalog and nothing else. Their keys are managed per group, and which models they hold is the catalog's to decide.
- These groups have no Add model, and Model settings does not offer them as a group to move a model into.
- The server refuses a new model in one of these groups unless it is one of the group's built-in models: saving it fails with "This group carries its built-in models only".
penguin config model addrefuses it the same way. A built-in model you deleted can be added back, which is what Sync presets does. - Models already in these groups stay where they are, including ones you added to a gateway group before this rule. They keep working, and you can edit them, rename them within the group, or delete them.
- A vendor group (DeepSeek, Google Gemini, OpenAI, Anthropic, Z.AI, Moonshot, MiniMax) supports only the vendor's own API. If one of its models has an id that cannot be routed that way, the model is marked and offers Move to Custom. Use Custom for OpenAI-compatible endpoints.
- The gateway groups keep the protocol their built-in models pin: OpenRouter uses
openai-responses, and the other OpenAI-compatible gateways use OpenAI Chat Completions, except for aggregate presets that pin a model-specific protocol.
Edit or delete a model
Select the model's card to open Model settings. Change the fields, select Confirm, and confirm the save. From the same dialog you can Test connection, Set as default model, Set as proxy vision model, or Delete model.
Changing Model ID or Group renames the entry; its credential and its default or proxy vision role move with it. Delete model removes the model's configuration and API key.
Create a model group with AI
Create with AI covers what an import cannot read: a model listing page that is not an OpenAI-compatible /models endpoint, a service described in words, or a built-in model to put back into its group.
[!TIP] For an OpenAI-compatible endpoint that lists its own models, Import models in the Add group dialog is faster.
- On the Models page, select Create with AI. The Add a model group with AI dialog opens.
- Paste the address of a model listing page or describe the service, or pick an example under Try an example.
- Select Edit in a new conversation. A new conversation with the Project's default agent opens with the prompt filled in.
- Send the prompt.
The fixed instructions tell the agent to use the penguin-config Skill and to:
- run
penguin config model add --provider <group> --model-id <upstream id> --project-id <project> --root <data root>once per model, adding--client-type openai --base-url <endpoint>for an OpenAI-compatible endpoint. The data root is named because a command's environment does not carry it; - when the source is a web page, fetch it first and add the models you named, or the most popular ones, about ten at most;
- ask once for a missing API key, or leave it empty for you to fill in on the Models page;
- never read or edit
.project_config.toml; - finish with
penguin config model list.
The Models page reloads the table on every visit, so the new group is there when you come back from the conversation.
Detect a custom model's protocol
Models in Custom and in groups you created speak one of AgentHub's generic protocols, and the dialog can find out which one a base URL serves. A new custom model starts with no protocol selected: the suffix at the right edge of the base URL field reads Select protocol.
To detect the protocol, select Detect at the top-right of the base URL field. It is always available, and no API key is needed. The server probes the URL with three cheap requests, in this order, and applies the first protocol the endpoint serves:
openai-responses:POST {base}/responses(OpenAI Responses API)ant-messages:POST {base}/v1/messages(Anthropic Messages API)openai-chat:POST {base}/chat/completions
A message names the protocol found, for example "Detected {name}; applied". The result lives only in the suffix, which shows the protocol path.
Detection tolerates common base URL mistakes:
- one
/v1too many (https://host/v1/v1); - one too few (
https://hostfor an API served underhttps://host/v1); - a whole endpoint URL pasted from a provider's documentation (
/chat/completions,/responses,/messages).
It probes the cleaned-up base first, then its neighbouring form: the trailing /v1 is removed if the URL has one, added if it does not. Each form is tried against the three protocols in order, six short probes at most. The base URL field is then rewritten to the form that answered: "Detected {protocol}; base URL normalized to {url}".
To set the protocol by hand, select the suffix. The menu lists OpenAI Responses (/responses), Anthropic Messages (/v1/messages), and OpenAI Chat Completions (/chat/completions), each with the path the client appends to your URL. A protocol you pick wins over detection, so an endpoint whose protocol you know never has to be probed.
If detection finds nothing, the suffix turns amber and a message says "Could not detect the protocol. Please check the API key and the base URL." This happens when the endpoint is unreachable, timed out, answered with something that is not an API, or serves none of the three paths. The endpoint still reports each probe's outcome for debugging.
Detection never blocks a save. If you select Confirm while the protocol is still unset, detection runs first and the button reads Detecting…. A hit is saved without a message. If nothing is found, the model is still saved, on OpenAI Chat Completions, with the message "Protocol not detected; saved as OpenAI Chat Completions".
How probing works
- Probes are minimal invalid requests with
{}bodies. They cost no Tokens and need no valid model id: an error in the protocol's own shape proves the route exists, a404or405means the path is not served, and HTML or gateway noise counts for nothing. - The probed URLs and auth headers are exactly what the AgentHub client uses after saving:
Authorization: Bearerfor the OpenAI protocols, andx-api-keyplusAuthorization: Bearerandanthropic-versionforant-messages. A detected protocol is one that will really work. - The server picks the probe credential in three steps: the API key typed in the dialog, else the key already stored for the entry, else the environment variable of the protocol that probe speaks (
ANTHROPIC_API_KEYforant-messages,OPENAI_API_KEYfor the two OpenAI protocols) — but only when the probed URL is that vendor's own endpoint. The choice is made per probe, because the protocol is what is being determined. None of these values reach the browser or the response. - Detection works with no credential at all, since a protocol-shaped
401identifies the route. A gateway or a private server is therefore probed anonymously: your vendor key is never sent to a URL you typed. - Nothing is inferred from the model id in these groups. Typing
claude-sonnet-5into a custom group does not select the Anthropic client or itsANTHROPIC_*key: custom groups fall back toopenai-chat, and the API key hint follows that. Vendor and gateway groups are not affected; their ids are known to the catalog, so they route by id or by the group's preset. - Entries created before detection existed keep
client_type = "openai", which is still an alias ofopenai-chat. They are rewritten only when you pick a protocol or a detection applies. An older, non-standard protocol value is shown read-only: "Protocol: {t} (kept as configured; not editable)". - Detection is available as
POST /api/projects/:id/models/detect(owner only); see Server API.
Detect vision support
Vision support can stay off until you ask the model. Select Detect next to the switch: Adelie sends the model one 1x1 PNG with a one-word prompt.
- If the model answers, the switch turns on: "This model accepts images; vision turned on".
- If the model says it does not take images, the switch turns off. That is a real answer, not an error.
- If the probe fails on authentication or the network, the switch stays as it was, and the message asks you to check the API key and the base URL.
[!NOTE] Unlike protocol detection, this probe is a real, billed request: an image request cannot be made free the way the protocol probes are. It runs only when you select Detect, never on its own and never on save.
The credential comes from the same chain as the connection test: the key typed in the dialog, else the stored key, else the environment variable where the endpoint is allowed one (see Set API keys), all resolved on the server. Vision support appears only for models that are not in the built-in catalog; catalog models already declare whether they accept images.
Set API keys
Each model carries its own API key, or none.
- One model. In Model settings, enter the key in API key. Once saved, the key is shown masked; leave the field empty to keep it, or select Clear stored API key to remove it.
- A whole group. On a group's header, select Enter key and enter the key. It is written to every model in the group, replacing the key each one had. Custom has no Enter key: its models each reach their own endpoint.
- No key. A model without a key uses the provider's environment variable on the server only when its requests go to that provider's official endpoint: the entry has no base URL (AgentHub's own
*_API_KEY/*_BASE_URLpairing then applies), or its base URL is the vendor's own endpoint. A row with its own base URL is never covered by the environment, not even whenOPENAI_BASE_URLnames the same server. Gateway groups (TokenDance, OpenRouter, Fireworks AI, SiliconFlow, the Qwen gateways, ModelScope), Custom, vLLM and groups you created point at other endpoints, so their models need their own key: a Session, a connection test or a group speed test on a keyless row there fails with "has no API key" instead of borrowingOPENAI_API_KEYorANTHROPIC_API_KEY. The Penguin Go group is the exception that proves the rule — its rows fall back to its ownPENGUIN_GO_API_KEY, never to a vendor's variable. The card and the dialog show when a key is read from an environment variable; see Built-in provider groups.
A key you type is stored in the hidden Project config file, which has mode 0600. The Web App always masks it.
Connect an account
Three built-in groups can get their key for you: TokenDance, Penguin Go and ModelScope. Their header shows Connect with a status beside it: Not connected, or Connected once the group holds a key, however the key got there. Once connected, the button reads Reconnect, which gets a fresh key or switches to another account. The key is written to every model in the group, replacing the key those models use now.
- On the group's header, select Connect.
- Select Open authorization page. The provider's authorization page opens in a new tab.
- Authorize there. The dialog, which shows "Waiting for the authorization to finish in the other tab…", reports the result on its own.
TokenDance creates a new key on your account; it does not read a key you already have. The provider sends the browser back to Adelie, which exchanges the one-time code and saves the key. If the page cannot redirect back, for example because the browser cannot reach the server at the address it was given, select Page can't redirect back? Enter the code by hand. The authorization page then shows a one-time code instead of redirecting.
- Paste the code into Authorization code.
- Select Submit code.
Penguin Go differs in four ways:
- The server polls Penguin Go for the result, so this group has no manual-code mode.
- Once the group is connected, a Sync action sits on the header right after Reconnect and reads the platform's catalog again; see The Penguin Go group. Reconnect stays available, so you can switch to another platform account.
- A key the platform reports as invalid or revoked reopens authorization on the Models page.
- If writing the delivered key locally fails, the server keeps that one delivery for a short while, so the write can be retried without authorizing again.
ModelScope differs in three ways:
- Authorization does not go through ModelScope's own pages but through an authorization bridge. The bridge holds ModelScope's client secret, runs the OAuth exchange on Adelie's behalf, and hands back an access token that calls api-inference directly. The bridge's address comes from the server-side
MODELSCOPE_BRIDGE_URLenvironment variable; see Environment variables. - The authorization page's address is the bridge's, opened as given, rather than assembled here the way Penguin Go's is. This group likewise has no manual-code mode.
- The access token expires; Adelie stores the refresh credential on the server and silently renews before model requests. Select Reconnect only when the refresh credential is missing or no longer valid.
Keep in mind:
- Only the Project owner can connect. With TokenDance, only their own signed-in session can finish it, which in practice is the tab the dialog is open in. The redirect itself is received without a session, because the browser the provider sends back is not always the one you started in, but it only hands the code over: nothing is exchanged and no key is saved until the dialog asks for the result.
- The whole exchange runs on the server. Neither TokenDance's PKCE verifier, Penguin Go's device secret, nor ModelScope's code and device secret ever reaches the browser, and the new key goes straight into the model table without passing through it. ModelScope's client secret is never in Adelie at all; only the bridge holds it.
- An authorization flow waits for at most ten minutes. ModelScope delivers an access token / refresh token pair: the access token is written to the model table, while the refresh token stays only in the server DB and is never returned to the frontend or written to the Project config.
- A delivered key is handed over only once. Penguin Go and ModelScope both keep that one delivery briefly if saving it locally fails, so the write can be retried without authorizing again. ModelScope leaves nothing to clean up in ModelScope's console — what it returns is a token for your own account, not a newly minted key.
- TokenDance hands over the new key only once. If saving it fails, authorize again and delete the unused key in the provider's console.
- A TokenDance key carries Adelie's app URL from the App attribution table, so calls made with it stay attributed even from another tool.
Account balances
TokenDance and DeepSeek report the balance of the account a key belongs to. Once one of these groups has a key, its header shows the balance in the currency chosen under Currency in the settings, converted at the same fixed rate of 7 as prices. For DeepSeek the key may also be the server's DEEPSEEK_API_KEY, which its models already fall back to (see Set API keys); TokenDance is a gateway, so its key must be stored on the group. An account holding several currencies shows their sum: ¥110 and $5 read ¥145, or $20.71. The server asks the provider with the stored key, so the key never reaches the browser.
- Two icons stand before the balance. The refresh icon reads it again; point at it to see the provider's own figures and when they were read. Answers are kept on the server for a minute; the refresh icon skips that.
- A balance that cannot be read shows "—"; point at the refresh icon for the reason.
- The pin keeps the balance next to your name at the bottom of the sidebar, in the same currency. One balance can be pinned at a time: pinning another replaces it. The pin is saved with your account, not in the browser. The pinned balance is read when the app loads and every five minutes after that.
The balance is read with GET /api/projects/:id/models/balance?provider=<group>, which every member of the Project may call.
Set the default model
New conversations use the Project's default model unless you pick another one. A new Project's default is deepseek-flash (DeepSeek V4.1 Flash), which reads images itself.
- Select the model's card to open Model settings.
- Select Set as default model and confirm.
The first model added to a table without a default becomes the default automatically. Setting the default also saves any unsaved changes in the dialog.
Set the proxy vision model
A model without vision cannot see images. When it reads an image with read_file, a proxy vision model describes the image for it. There is none by default.
- Open Model settings for a model with Vision support on.
- Select Set as proxy vision model and confirm.
The proxy vision role is cleared when that model is deleted or its vision is turned off. For a model with vision = false, such as deepseek-v4-pro, the text-only member of the DeepSeek group, images from the conversation are saved to the Session scratchpad and handed over as a file path in the text. read_file passes an image to the proxy vision model for a description instead of returning it. See Tools & Approval.
Test a connection
In Model settings, select Test connection (owner only). The test uses what is in the dialog right now, including a key you typed, the base URL, the protocol, and the Fast mode switch, so problems show up before you save. The result reads "Connected ({ms} ms)" or "Failed: {msg}".
Measure speed
To compare the models in a group:
- On the group's header, select the speed test icon (Speed test).
- Select Start.
Adelie sends one real request to each model in turn, which uses a small amount of your API quota, and shows on each card:
- the time to first token, in milliseconds: green under 1000, yellow up to 3000, red above;
- the output rate, in Tokens per second: green at 40 or more, yellow at 15 or more, red below.
While the test runs, the same icon stops it (Stop speed test): the model being measured finishes, no further request is sent, and the results so far stay. Results stay only on the page and are gone after a reload.
Sync preset models
Adelie updates can change the built-in catalog of preset models. When they do, the Project owner sees:
- a red dot on Models in the sidebar;
- a notice on the page, "Changes detected: {added} new, {updated} to upgrade", with Update now and Dismiss;
- a Sync presets button in the header.
Update now lists the models it will touch; confirm with Sync presets. The Sync presets button in the header syncs right away, without the list.
Syncing:
- adds catalog models the Project does not have, retired rows excepted: one the Project already has is kept current, but a Project without it never gets it (see Preset models);
- resets each existing catalog model's vision flag, context window, protocol, prices, and base URL to the catalog's values;
- fills in an empty display name, but never overwrites one;
- never touches API keys, Max output tokens, fast mode, or models and groups you added yourself. The one exception is a built-in preset row without a key: where its group and endpoint hold exactly one key — the usual shape of a gateway group — it takes that key instead of being drawn as having no key configured. A group holding two different keys leaves it blank, and a model you added yourself is not one of these.
Dismiss hides the notice until a later catalog change.
Thinking levels
The thinking level sets how much the model reasons before it answers. There are six levels: none | low | medium | high | xhigh | max. Each agent has a default, model.thinking_level in system_config.yaml (see Agent config). A new agent starts at medium.
The pickers offer low and above. Many models cannot turn thinking off, but a stored none is still valid and still displays. Every level is labeled with the value it sends, so the label names exactly what goes on the request.
maxis the deepest tier. Each client maps it to the deepest effort its vendor accepts and falls back silently where there is no such tier, so picking it never fails. On Gemini and MiniMax M3 it lands on the same effort asxhigh.- For MiniMax M3,
nonemaps directly toreasoning.effort = "none". - DeepSeek V4 accepts
low,highandmax, and foldsmediumandxhighintohighon its side. Pickmaxfor DeepSeek's deepest effort.
In a new chat
The picker next to the model selector changes the selected agent's default right away. It applies from that agent's next conversation.
In a conversation
The picker shows the level this conversation uses, which starts as the agent's default.
- A level you pick is saved on the conversation and applies from the model's next request. It never changes the agent's default.
- Changing the level mid-conversation invalidates the model's cached context, which raises cost.
- If the conversation has history, a Switch thinking level dialog offers Compact, then switch, which is cheaper, or Switch anyway. Compacting first is not available while the conversation is still working.
To change an agent's default in its settings, see Runtime tab.
Fast mode
Fast mode sends a model's conversation requests to the provider's faster serving tier, at premium prices. It is off by default, and existing configs are not affected.
Turn fast mode on or off per model in one of three ways:
- The Fast mode switch in the model dialog
--fast-mode/--no-fast-modeonpenguin config model addfast_mode = truein the entry
Turning it on asks for confirmation first, because it changes what the model costs. A model with fast mode on shows the Fast tag.
With fast mode on, conversation requests carry AgentHub's fast_mode flag:
- OpenAI-protocol clients send
service_tier: "priority". - Anthropic-protocol clients send
speed: "fast"with the fast-mode beta header.
Fast tiers are billed at the provider's premium prices: MiniMax charges 1.5x its standard rate, and OpenAI and Anthropic publish separate premium rates.
[!WARNING] The recorded per-Token prices do not change, so costs shown for fast-mode usage are underestimated unless you raise the entry's prices.
Which models offer it
Whether a fast tier exists depends on the AgentHub client a model routes to, not on the model entry. The switch appears only where that client actually sends the parameter:
| Routed client | Fast mode |
|---|---|
OpenAI protocol (openai_chat, openai_responses, gpt6, minimax_m3) |
sent as service_tier: "priority" |
Anthropic protocol (ant_messages, claude5) |
sent as speed: "fast" plus the beta header |
| Gemini, GLM, Kimi, DeepSeek, OpenAI embeddings | rejected — no toggle |
| Claude on Bedrock, or a Claude 4.6 id | rejected — no toggle |
Routing follows the entry's client_type, or its model_id when none is set, so the same upstream id can land in different places. A Kimi model added under a gateway group (client_type = "openai") can use fast mode, while the same id routed to Kimi's own client cannot. A custom model behind your own base URL keeps the switch: it speaks the OpenAI protocol and may well be OpenAI, but a third-party server is free to accept the parameter and serve the standard tier anyway.
Two things the switch cannot check for you:
- Anthropic's fast mode is a limited research preview. Until your organization is granted access, requests return a 429 rate-limit error. The confirmation says so for Anthropic-protocol models.
CLIENT_TYPEandANTHROPIC_BASE_URLin the server's environment override the entry, and can route a model somewhere the switch did not anticipate.
[!NOTE] If a request still reaches a client that rejects
fast_mode, AgentHub refuses it before any network request. The conversation ends that turn immediately with the provider's message and a pointer to the setting. A rejection that will always repeat is never retried.
An entry that stores fast_mode = true on a model that cannot serve it keeps its switch in the dialog, marked unsupported, so you can always turn it off.
The connection test sends the dialog's current fast-mode state, so Test connection shows a fast-mode rejection before you save. Background requests, such as Session title generation and read_file's proxy vision reads, never use fast mode. Only the conversation's own requests do.
Connect a local or self-hosted endpoint
A local inference server can join a Project in two ways.
Add the model to the vLLM group
Add the model to the vLLM group. The protocol is fixed to openai-chat-vllm-adapter, and the group has no preset base URL, so set Custom base URL to your server. Set API key too: the server's key, or any placeholder if it checks none. A row with its own base URL is never covered by the server's OPENAI_API_KEY, so a keyless row is refused.
The group ships eight preset models at a price of 0:
Qwen/Qwen3.8-Flash-NextQwen/Qwen3.8-27BQwen/Qwen3.6-35B-A3BQwen/Qwen3.5-0.8BQwen/Qwen3.5-9Bdeepseek-ai/DeepSeek-V4-Prodeepseek-ai/DeepSeek-V4-Flashdeepseek-ai/DeepSeek-V4-Flash-Vision-Exp
Their context windows are each model's native length: 262,144 for the Qwen models, 1,000,000 for the DeepSeek V4 models.
Add a custom entry
Add a custom model with:
client_type = "openai-chat"base_urlpointing at the server, for examplehttp://127.0.0.1:8000/v1- the served model name as
model_id api_key: the server's key, or any placeholder if it checks none — the environment'sOPENAI_API_KEYdoes not cover a server of your own
Protocol detection settles on openai-chat for such servers, and the base URL field's suffix menu selects it by hand.
Make a local server run smoothly
Whichever way you add the model, check two settings:
- Enable tool calling on the server. For vLLM, start the server with
--enable-auto-tool-choiceand the--tool-call-parserfor your model, for examplehermesfor Qwen orllama3_jsonfor Llama 3.x. Without them, tool calls arrive as plain text and the agent loop cannot run anything. - Set the entry's
context_windowto the server's real window. For vLLM, that is the--max-model-lenvalue, for example32768.
The per-request output limit and the compaction threshold both follow this window. Requests limit max_tokens to what the window still fits, and compaction runs before the window overflows, so you do not need to tune max_tokens by hand.
[!NOTE] If the field is left unset, the per-request output limit is off and compaction assumes a 128000 window, so a server with a smaller real window rejects requests.
Built-in provider groups
The table below lists the built-in groups and the environment variables their models fall back to when an entry has no key. The catalog source is packages/core/src/state/model-catalog.ts. Each group also has a _BASE_URL variant, for example ANTHROPIC_BASE_URL. The Models page lists the groups in this order, followed by the groups you create. A gateway group's rows carry the gateway's endpoint, so they never fall back: the variable in their row is the one their protocol client reads, and exactly because it holds your vendor key it is not sent to the gateway (see Set API keys).
| Provider | API key env var | Notes |
|---|---|---|
| tokendance | OPENAI_API_KEY |
OpenAI-compatible gateway, preset base URL https://tokendance.space/gateway/v1; model ids are bare, with no vendor prefix (e.g. glm-5.3, kimi-k3); pricing is the gateway's own CNY rates, several of them currently discounted |
| penguin-go | PENGUIN_GO_API_KEY |
Preset relay group, fixed base URL https://token.penguin.ooo/api; its header connects for you or takes a key you enter by hand. See The Penguin Go group |
| opencode-go | OPENAI_API_KEY |
OpenCode Go subscription gateway. Each model pins its own protocol: Chat Completions or Responses at https://opencode.ai/zen/go/v1, Anthropic Messages at https://opencode.ai/zen/go (that client's variable is ANTHROPIC_API_KEY). See The OpenCode Go group |
| deepseek | DEEPSEEK_API_KEY |
Group of the default model |
| openrouter | OPENAI_API_KEY |
OpenAI-compatible gateway, preset base URL https://openrouter.ai/api/v1 |
| fireworks | OPENAI_API_KEY |
Fireworks AI (OpenAI-compatible), preset base URL https://api.fireworks.ai/inference/v1; API model ids look like accounts/fireworks/models/<slug> |
GEMINI_API_KEY |
||
| openai | OPENAI_API_KEY |
|
| anthropic | ANTHROPIC_API_KEY |
|
| siliconflow | OPENAI_API_KEY |
OpenAI-compatible gateway, preset base URL https://api.siliconflow.cn/v1 |
| zhipu | ZAI_API_KEY |
|
| moonshot | MOONSHOT_API_KEY |
|
| minimax | MINIMAX_API_KEY |
Direct MiniMax M3 Responses client (client_type = "minimax-m3"): MiniMax-M3 with a 1,000,000-token context window and vision; preset base URL https://api.minimax.io/v1; accepts a Token Plan Subscription Key or pay-as-you-go API key |
| qwen-pay-as-you-go | OPENAI_API_KEY |
Qwen pay-as-you-go (DashScope's OpenAI-compatible endpoint), preset base URL https://dashscope.aliyuncs.com/compatible-mode/v1; resold third-party models keep vendor-prefixed ids (e.g. kimi/kimi-k3) |
| qwen-token-plan | OPENAI_API_KEY |
Qwen Token Plan subscription gateway, preset base URL https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1; pricing from each model page's official list price (the preview model has only a quota-multiplier promo, no list price) |
| modelscope | OPENAI_API_KEY |
ModelScope's OpenAI-compatible api-inference gateway, preset base URL https://api-inference.modelscope.cn/v1; ids are the upstream repo names (deepseek-ai/DeepSeek-V4.1-Flash, Qwen/Qwen3.8-27B); the group's header authorizes a token for you through an authorization bridge, or takes one you set by hand. See The ModelScope group |
| abliteration | OPENAI_API_KEY |
Abliteration's own line of "abliterated" (refusal-ablated) models, OpenAI-compatible, preset base URL https://api.abliteration.ai/v1; keys look like ak_…; all four presets pin Chat Completions. See The Abliteration group |
| volcengine | OPENAI_API_KEY |
ByteDance's Volcengine Ark (火山方舟), OpenAI-compatible, preset base URL https://ark.cn-beijing.volces.com/api/v3; the Doubao Seed line plus the GLM / Kimi / DeepSeek models Ark resells — 11 presets, all pinning Chat Completions. See The Volcengine Ark group |
| vllm | OPENAI_API_KEY |
Self-hosted vLLM servers: protocol fixed to openai-chat-vllm-adapter, no preset base URL, eight preset models priced at 0 (see Connect a local or self-hosted endpoint) |
| custom | OPENAI_API_KEY |
Any OpenAI-protocol endpoint; ships one preset, Atria Dawn Preview (Anthropic Messages API at api.atria-asi.ai, needs its own key, 256K window, priced at $0 until the vendor publishes prices) |
The OpenAI-compatible gateway groups (openrouter / fireworks / siliconflow / tokendance / qwen-pay-as-you-go / qwen-token-plan) go through AgentHub's generic OpenAI-protocol clients, whose variable is OPENAI_API_KEY; a keyless row there is refused rather than sent your OpenAI key. The same holds for custom, vLLM and user-created groups unless the row's base URL is the vendor's own endpoint. ModelScope also uses the OPENAI_* credential variables because its credential is an api-inference token, and all three presets pin the generic Responses protocol; a keyless ModelScope row is refused the same way.
- The OpenRouter group uses the Responses client (
client_type = "openai-responses") for its presets and for any model you add to it, because OpenRouter serves the Responses API at that same base URL for every model it resells. - The other gateway presets use the Chat Completions client (
client_type = "openai-chat"). - ModelScope is an aggregate gateway like Penguin Go, but all three of its presets use AgentHub's generic Responses client (
client_type = "openai-responses"). - Those gateway clients read the same
OPENAI_*variables, so the credential rules are identical either way. - The OpenCode Go group is the exception: its models use three protocols, so each one pins its own; see The OpenCode Go group.
The direct MiniMax M3 client reads MINIMAX_API_KEY. The built-in MiniMax preset uses https://api.minimax.io/v1. MINIMAX_BASE_URL is read only for entries without their own base_url.
The Penguin Go group
penguin-go is a built-in group like TokenDance: a relay behind the fixed base URL https://token.penguin.ooo/api. A new Project gets the group's catalog models right away; a Project created before the group adds them with Sync presets.
The group's key comes from its header; see Connect an account. Connecting, and the Sync action that follows it, also read the platform's own model catalog:
- Models the platform offers and the Project does not have are added, with their protocol, endpoint, display name, context window, vision flag and list price. Pure embedding models are left out.
- Models the Project already has keep their endpoint and everything else you configured. Only their three prices and their client protocol are refreshed,
max_tokensstays unset so the agent's setting applies, and nothing is ever deleted. - The platform's promotions replace the ones stored for this group. As in every other group,
.project_config.tomlholds the list price and the promotion lives in the server's database; Sync presets never sets one, and each authorization or Sync replaces them. If that record is lost, usage is priced at the list price until the next one writes it back.
The platform quotes peak rates in USD per million Tokens. The group's DeepSeek rows follow DeepSeek's current line-up, deepseek-flash and deepseek-v4-pro, and declare the same off-peak schedule as the direct DeepSeek group, so their cards and cost records use half price outside Beijing weekday 9:00–12:00 and 14:00–18:00.
The OpenCode Go group
opencode-go holds the 27 models OpenCode lists for its Go subscription. One key serves all of them: set it once with Enter key on the group header.
- Protocols. OpenCode serves each model on one of three endpoints, so each row pins its own
client_typeand base URL. Chat Completions (openai-chat) and Responses (openai-responses) models usehttps://opencode.ai/zen/go/v1. Anthropic Messages (ant-messages) models usehttps://opencode.ai/zen/go, because the client adds/v1/messagesitself. Like every gateway's rows, none of them falls back toOPENAI_API_KEYorANTHROPIC_API_KEY: the key goes on the group. A model you add to the group yourself getsopenai-chatand the/v1base URL. - Prices. Go is a monthly subscription whose usage limits are dollar amounts per model: a monthly allowance, of which at most 20% can be used in five hours and 50% in a week. The rows record the per-token rates a request draws from that allowance, so for this group the cost center shows how much of it you used, not a bill.
gpt-5.6-luna,grok-4.6,qwen3.7-plusandqwen3.6-plusrecord their base tier, which covers up to 272K, 200K, 256K and 256K input tokens respectively. The four DeepSeek models follow DeepSeek's off-peak schedule; see Prices and promotions. - Opt-in and regions. Five models answer with an error until the key's OpenCode workspace opts in to them.
muse-spark-1.3-contributorandmuse-spark-1.2-contributorneed consent to Meta training on prompts and completions.deepseek-v4.1-flash,deepseek-v4-flashanddeepseek-v4-proneed consent to being served from China. Some models also refuse requests from certain regions: from mainland China,gpt-5.6-lunaand both Muse Spark models answer with an error. - Session header. Requests to the group name their conversation in
x-opencode-session; see App attribution.
The ModelScope group
modelscope is an aggregate gateway group: one ModelScope api-inference endpoint behind the preset base URL https://api-inference.modelscope.cn/v1. Model ids are upstream repo names, so they keep their vendor prefix (deepseek-ai/DeepSeek-V4.1-Flash, Qwen/Qwen3.8-27B). All three preset rows pin AgentHub's generic Responses client (client_type = "openai-responses") and send inference requests to {base_url}/responses. A new Project gets these presets right away; an existing Project updates its stored protocol with Sync presets or the next ModelScope authorization.
The group's key comes from its header; see Connect an account. Connecting goes through an authorization bridge, which holds the ModelScope client secret and returns an api-inference access token / refresh token pair, rather than through ModelScope's own pages. Nothing else about the group is special: inference requests go straight to https://api-inference.modelscope.cn/v1 and never through the bridge. The access token is written into .project_config.toml like any other group key, while the refresh token stays only in the server DB. The access token expires, and Adelie silently renews it before model requests; reconnect from the header only when the refresh token is missing or no longer valid.
The preset rows carry no price. ModelScope bills for api-inference and its model pages publish no read-able rate, so the rows are left unpriced: the models page shows no price badge on them and the cost center reports their usage as uncosted. That is the catalog's way of recording "nobody has looked this up" — see Prices and promotions.
The Abliteration group
abliteration carries abliteration.ai's own line of "abliterated" models — the refusal-ablated fine-tunes the service is named after. The endpoint is OpenAI-compatible: /chat/completions, /responses and /models all sit on https://api.abliteration.ai/v1, and a key from the console looks like ak_…. Set it once on the group header with Enter key.
- Presets.
abliterated-model-large-v2(the vendor's recommended default),abliterated-model-large,abliterated-model-large-flashandabliterated-model. The first two take text only at a 1,000,000-token window;flashtakes text and images at 1,048,576;abliterated-modeltakes both at 262,144. - Protocol. None of these ids matches a rule AgentHub routes by, so every row pins the Chat Completions client (
client_type = "openai-chat") and carries the endpoint on itself. The same endpoint also serves/responses; change the row's protocol if you prefer it. As in every gateway, a keyless row is refused rather than sent your OpenAI key. - Prices. Read from the service's own model list, in USD per million Tokens: input 1 or 3, output 2, 3 or 5, and cache hits read at 0.1 or 0.3. It charges no separate cache-write fee, so
cache_writerecords the input rate. - At most four images per request. That is the service's own limit, and a request past it is refused outright (
400 … media_count_exceeded); because a conversation replays its images on every request, such a conversation fails for good. Adelie therefore replaces the oldest images with a one-line[image omitted: …]placeholder before each request, keeping the newest four (images in the new input count against them first; when a single turn carries five on its own, its oldest ones become placeholders the same way). The conversation and its Trace keep every picture — only what one request carries is reduced.
The Volcengine Ark group
volcengine is ByteDance's own model platform, Volcengine Ark (火山方舟) — the endpoint the Doubao / Seed line (doubao-seed-*) is served from. It is OpenAI-compatible at https://ark.cn-beijing.volces.com/api/v3; a key from the Ark console is set once on the group header with Enter key.
- Presets (11). Seven from the Doubao Seed line —
doubao-seed-evolving,doubao-seed-2-1-pro-260915,doubao-seed-2-1-lite-260915,doubao-seed-2-1-turbo-260628,doubao-seed-2-0-lite-260428,doubao-seed-2-0-mini-260428,doubao-seed-character-260628— and four Ark resells:glm-5-3-flash-260828,kimi-k3-1-pro-261024,deepseek-v4-1-flash-261017,deepseek-v4-pro-ga-260813. Ark's ids carry a version date (-260915and the like) and must be copied verbatim; Ark's model units, custom endpoints and Coding Plan subscription are not catalogued. - Protocol and credentials. AgentHub has no Ark client, so every row pins the Chat Completions client (
client_type = "openai-chat") and carries the endpoint on itself. As in every direct vendor group, a keyless row is refused rather than sent your OpenAI key. The GLM, Kimi and DeepSeek rows are sold by Ark: their ids and prices are Ark's own. - Video input. Seven of the eleven rows accept video — every Doubao Seed row but
doubao-seed-2-1-lite-260915, plus the resoldglm-5-3-flash-260828— and their cards carry the Video tag: attach a video with the paperclip or by dragging it into the composer, and that request carries the video itself, so the model can describe, summarize or answer questions about it. The remaining four (2.1 Lite, Kimi and the two DeepSeek rows) receive an[attached file: …]line instead: the video lands in the session scratchpad and the agent works with it through its own tools. - Prices. From Ark's model-pricing page, 在线推理(常规) table, in CNY per million Tokens (input non-audio / cache-hit non-audio / output), stored in USD at the fixed rate of 7. Ark prices by input length and only the base tier is recorded here;
deepseek-v4-1-flash-261017follows DeepSeek's off-peak schedule, at half price outside Beijing weekday 09:00–12:00 and 14:00–18:00. - What is not here. Ark's image generation (Seedream), video generation (Seedance), 3D and embedding models are not chat models, so a Session cannot hold a conversation on one and they stay out of the catalog; to generate a video, see the
use-seedanceplugin in the plugin library: one sentence, one mp4 in the workspace.
Preset models
The preset catalog includes, among others:
deepseek-flash/deepseek-v4-pro/deepseek-v4.1-flash-1017MiniMax-M3gemini-3.8-flashclaude-opus-5/claude-opus-4-8/claude-sonnet-5gpt-6-astra/gpt-5.6/gpt-5.5glm-5.3/glm-5.3-flash/glm-5.3-flashx/glm-4.7-flash(Z.AI's free tier)kimi-k3/kimi-k3.1-proqwen3.8-max/qwen3.8-flashseed-2.1-pro/seed-2.1-turbo/seed-evolvingdots-3-note-preview(free on TokenDance, 512K context)deepseek-ai/DeepSeek-V4.1-Flash,Qwen/Qwen3.8-27B,Qwen/Qwen3.8-Flash-Next(ModelScope's api-inference; preset rows with no price)abliterated-model-large-v2/abliterated-model-large-flash(Abliteration's refusal-ablated models)
The list is not exhaustive.
- DeepSeek images.
deepseek-flashis V4.1 Flash and reads images;deepseek-v4-prois the V4 Pro 0813 release and is text-only. To send an image, usedeepseek-flash. - Retired rows. DeepSeek still accepts
deepseek-v4-flashanddeepseek-v4-flash-vision-exp, and serves both from V4.1 Flash. They are no longer presets, but the catalog keeps them, together with TokenDance'sdeepseek-v4-flash-vision-exp, as retired rows: a Project that still carries one keeps its display name, and Sync presets keeps its price current. A retired row is never added to a Project that does not have it, and a new Project never gets one. - OpenAI twice. The whole OpenAI line-up is listed twice: directly (your own OpenAI key, list prices) and on OpenRouter as
openai/<id>(the gateway's rates, which follow its running promotions). - GLM-5.3 Flash six times. It appears directly as
glm-5.3-flash, under the same id on TokenDance and OpenCode Go, and as OpenRouter'sz-ai/glm-5.3-flash, Fireworks AI'saccounts/fireworks/models/glm-5p3-flashand Qwen pay-as-you-go'sZHIPU/GLM-5.3-Flash. Every row accepts images: AgentHub's GLM client forwards image parts for this one GLM id, every other GLM id refuses them, and the gateway rows go through the generic OpenAI-compatible clients, which carry images for any id. What the rows do not share is the price: each records what its own seller charges, so they disagree while a promotion runs. - OpenRouter free tier. The catalog carries the
:freemodel variantnvidia/nemotron-3-ultra-550b-a55b:freeand theopenrouter/freeunified Free Models Router. They cost nothing, but OpenRouter's free-tier rate limits and data policy apply. - Zhipu's free tier.
glm-4.7-flashis the Z.AI group's one $0 row: Z.AI's price list readsFreeon all four of its buckets, and 智谱开放平台 files the model under its free-model list. Text in, text out, 200K context with a 128K output cap. Its id carries none of theglm-5substring AgentHub routes GLM on, so the row pins the GLM client the waydeepseek-flashand MiniMax M3 pin theirs; it pins no endpoint, since both platforms serve the same id —ZAI_BASE_URLpicks which one is billed. It sits below the GLM-5 rows because it is older: Z.AI dates GLM-4.7-Flash to 2026-01-19 and GLM-5 to 2026-02-12.
Prices and promotions
Three price buckets. Each model records
cache_read,cache_writeandoutputprices in USD per million Tokens. The cost center bills usage against them.Rows with no price. The pricing block can be absent altogether, which records "nobody has looked this vendor's price up" rather than "free": such a row shows no price badge on the Models page, and the cost center reports its usage as uncosted. ModelScope's preset rows are the catalog's only ones — ModelScope bills for api-inference, but its model pages are client-rendered and carry no read-able rate. Three zeros would be worse than absent: they would read as the free tier and badge a billed gateway "Free".
Base tier only. Where a vendor's prices step up with input size, the catalog records the base tier. MiniMax M3 records MiniMax's standard pay-as-you-go tier at 512K input tokens or below; above that, every rate doubles, and the priority tier is 1.5x, so long-context and priority usage is underestimated. OpenAI (above 272K) and Gemini 3.1 Pro (above 200K) follow the same convention.
DeepSeek off-peak. The direct DeepSeek rows record the official peak prices and declare DeepSeek's off-peak schedule: outside Beijing time 9:00–12:00 and 14:00–18:00 on weekdays, every bucket is halved. The Models page shows a
50% offtag during those hours, and the cost center bills at that rate.- Eleven resold rows follow the same schedule because their sellers pass DeepSeek's windows through: TokenDance's
deepseek-v4-flash-0731,deepseek-v4-pro-0813,deepseek-v4.1-flashanddeepseek-v4.1-flash-1017; OpenRouter'sdeepseek/deepseek-v4.1-flash; Penguin Go'sdeepseek-flashanddeepseek-v4-pro; and OpenCode Go'sdeepseek-v4.1-flash,deepseek-v4-flash,deepseek-v4-flash-vision-expanddeepseek-v4-pro. - Two of those rows, TokenDance's
deepseek-v4-flash-0731anddeepseek-v4-pro-0813, can only be approximated: their peak rate is the promoted one (20% off the list) while the gateway bills half the list outside the windows (50% off, no promotion on top), and a row holds one rate — so their off-peak usage is estimated 20% below what the seller charges.deepseek-v4.1-flashanddeepseek-v4.1-flash-1017run the same promotion on both tiers, so halving them lands exactly. Peak is exact on all of them. - Qwen bills the DeepSeek models it resells on a schedule of its own, half price from 22:00 to 8:00 Beijing time every day.
deepseek-v4.1-flashin both Qwen groups, and the Token Plan'sdeepseek-v4-pro-0813, declare that one instead, and the tag's tooltip names the windows of whichever schedule the row follows. - The stored price is always the rate the peak window actually bills, so what is on disk does not depend on the hour a Project was created or synced.
- Eleven resold rows follow the same schedule because their sellers pass DeepSeek's windows through: TokenDance's
Flat promotions. Seven TokenDance models are discounted today:
glm-5.3,glm-5.3-flash,qwen3.8-maxanddeepseek-v4-proat 10%- the three Doubao Seed rows (
seed-2.1-pro,seed-2.1-turbo,seed-evolving) at 50%
Promotions do end:
kimi-k3's 40% and the 10% ondeepseek-v4-flash-0731anddeepseek-v4-pro-0813had all stopped by the 2026-10-27 check, so those rows dropped the field and go on recording the seller's list price.Gemini 3.8 Flash, 3.7 Flash and 3.6 Flash are also 50% off, both in the google group and on OpenRouter (
google/gemini-3.8-flash,google/gemini-3.7-flash,google/gemini-3.6-flash), because Google halves them through 2026-12-31. A Project is preset with the list price: the server keeps the promotion beside it, in its own database rather than in.project_config.toml, and takes it off when usage is priced, so the cost center charges what the seller charges. The model card shows the rate being billed right now as a tag, and the model dialog says These are list prices. A running promotion takes N% off them; changing a price cancels it.Your own prices. Editing a row's price cancels its promotion and takes the discount tag off the card: the figure is then yours, not the seller's.
The per-Project model table
Each Project's models are recorded in the hidden .project_config.toml. Maintain it through the Models page or the CLI (penguin config model add / default / list, see CLI Reference).
[!WARNING] Do not edit
.project_config.tomlby hand.
Each ModelEntry has these fields:
| Field | Meaning |
|---|---|
provider |
Config group name; paired with model_id it forms the unique key |
model_id |
Upstream request id |
context_window |
Context window (tokens). Load-bearing, not just display: each request's effective output cap and the compaction threshold are derived from it, so requests never ask for more output than the window still fits. Unset (or implausibly small, under 4096): the output clamp turns off and compaction derives from an assumed 128000 — set the real value for models with smaller windows. The Web dialog writes 1,000,000 when a model that is not in the catalog leaves the field blank (a hand-added entry is a known model, not an unknown window); narrow it when the endpoint serves less. penguin config model add writes no default at all when --context-window is omitted |
max_tokens |
Optional per-model output cap (max output tokens per request). When set it overrides the agent's model.max_tokens; unset inherits it. The cap is a ceiling, not the literal wire value: each request sends min(max_tokens, context_window − estimated input − safety margin), so small-window models work without hand-tuning it. Omitting the field on a Web full-table save clears it |
client_type |
Protocol hint (openai-chat for Chat Completions, openai-responses for the Responses API, ant-messages for Anthropic Messages, …); inferred by AgentHub from the model id when omitted. Custom endpoints use one of those three generic protocol clients, and the Web dialog can detect which one a base URL serves. The pre-0.4.2 spelling openai is a deprecated alias and is normalized to openai-chat when the config is read |
display_name |
Display name |
vision |
Whether image input is supported, default true |
video |
Whether video input is supported, default false (the opposite default of vision): set to true only for a model that really takes a video. A marked model gets the video as a content part on the request; an unmarked one gets a file path instead, see The Volcengine Ark group. Preset from the catalog's supportsVideo; the Web App offers no switch for it yet |
fast_mode |
Optional fast mode (off by default): opts the model's Session requests into the provider's faster serving tier at premium pricing. Only true is ever persisted — omitting the field on a Web full-table save clears it. Models without a fast tier reject requests carrying it (see Fast mode) |
pricing |
Three price buckets (unit usd_per_mtok, USD per million tokens): cache_read / cache_write / output |
api_key / base_url |
Inlined credentials, both optional; when blank, AgentHub falls back to environment variables |
The file also holds default_model, and optionally vision_model, the proxy vision model. File shape (illustrative):
default_model = { provider = "deepseek", model_id = "deepseek-flash" }
vision_model = { provider = "google", model_id = "gemini-3.1-pro-preview" }
[[models]]
provider = "deepseek"
model_id = "deepseek-flash"
context_window = 1000000
client_type = "deepseek-v4"
base_url = "https://api.deepseek.com"
[[models]]
provider = "custom"
model_id = "my-model"
client_type = "openai-chat"
base_url = "https://llm.example.com/v1"
api_key = "sk-..."
App attribution
Some gateways read a request header that files a call under the app that made it, for their own app rankings, usage reports or routing.
The catalog decides these headers by endpoint host, not by the entry's provider group. An entry filed under custom whose base URL points at such a gateway carries the same headers. Only the entry's own base_url counts: an endpoint supplied through OPENAI_BASE_URL is resolved inside AgentHub, is not visible on this side, and is therefore not attributed.
| Endpoint | Header | Value |
|---|---|---|
openrouter.ai |
HTTP-Referer |
https://penguin.ooo/ |
openrouter.ai |
X-OpenRouter-Title |
Adelie |
openrouter.ai |
X-OpenRouter-Categories |
cli-agent,personal-agent |
tokendance.space |
X-App-URL |
https://penguin.ooo/ |
opencode.ai |
x-opencode-session |
The Session id; a request outside any Session (a connectivity test, a vision probe) sends a fresh id of its own |
Every other endpoint, including every direct vendor and every gateway that reads no such header, receives no extra headers. The OpenRouter and TokenDance headers state the app's identity only. The OpenCode header names the conversation, because that gateway routes and caches each conversation by it and refuses a request that names none; no header carries anything about the user or the agent.
How it works
One gateway
All model access goes through one gateway library, @prismshadow/agenthub (AutoLLMClient). The core defines only a thin LLMInterface (see Interfaces). Per-provider protocol adaptation happens inside AgentHub, so 1000+ online and local models are reachable, including any OpenAI-compatible endpoint. The protocol translation lives in packages/core/src/llm/generative-model.ts.
Model identity
A model's identity is always the (provider, model_id) pair. provider is a config group name, and model_id is the upstream request id, sent to AgentHub unchanged. The two are independent fields, and joining them into one string is forbidden anywhere in the pipeline.
Every interface that names a model takes the complete pair: the CLI, the HTTP API and the SDK all reject half a reference instead of completing it. The provider is never inferred from the model id and has no default, because gateways resell vendor models under their upstream ids; a guessed group would send the entry's credential to a vendor nobody named.
Where a model reference is optional (penguin run / chat, Session creation, scheduled tasks), the choice is between the whole pair and nothing. Omit both halves to use the Project's default model.
Models and agents
An agent never binds a model. The model is chosen when a Session is created, so the same agent can run different Sessions on different models, and a Session can switch models later: the model picker in the conversation's toolbar compacts the context on the current model and continues the conversation on the new one (see Sessions & Traces).
The /model command instead opens a new conversation on another model, by handoff:
- It opens a new Session for the same agent on the new model, in the current Workspace.
- The new Session's first message carries a
[model_switch_from]block with the source Session's id and its Trace file path.
The history is not injected into the new context. Some models require thinking payloads and fidelity when history is replayed, and these cannot cross models. The model reads the Trace file itself when it needs to, and the source Session stays untouched.