Models

An agent names each model as a {provider, model} pair, and the only valid pairs are the ones GET /v1/catalog returns. A config naming anything else is refused on save, with the valid pairs listed. The catalog is the source of truth for every model, its flags and its price; this page gives the rules for reading it.

curl https://api.talqing.com/v1/catalog \
  -H "Authorization: Bearer $TALQING_API_KEY"

const catalog = await talqing.catalog.get();

for (const entry of catalog.llm) {
  console.log(entry.provider, entry.model, entry.reasoning_efforts, entry.priority !== null);
}

catalog = talqing.catalog.get()

for entry in catalog["llm"]:
    print(entry["provider"], entry["model"], entry["reasoning_efforts"], entry["priority"] is not None)

From an MCP client, the same data is get_catalog; OpenRouter models are search_models and list_model_hosts.

Every model runs on your provider key. An agent will not publish until the workspace has a key for each provider it uses, fallbacks included. See provider keys.

What the catalog returns

One array per kind — llm, stt, tts, realtime, avatar, noise_cancellation — plus providers, languages, turn_detector_languages, system_vars and the platform fees. Each entry carries provider, model, label, channel (where it may run), pricing (USD, billed by the provider on your key) and an optional note. The flags that change what you may configure:

Kind	Field	Rule
`llm`	`reasoning_efforts`	Values `llm.reasoning_effort` accepts, fastest first. Empty: the model takes none.
`llm`	`priority`	Present: the model sells a priority lane, with its own `pricing`. `null`: `llm.priority` is refused.
`llm`	`builtin_tools`	Provider-run tools `llm.builtin_tools` may switch on, with options and a `price_note`.
`llm`, `realtime`	`vision`	Whether the model reads images. See vision and images.
`stt`	`streaming`	`false` is a batch model. See speech-to-text.
`stt`, `tts`, `realtime`	`languages`, `default_language`, `language_required`	What the agent’s `language` may be. See language.
`tts`, `realtime`	`supports_speed`, `speed_min`, `speed_max`	Range for `speed`; without speed support only `1.0` is accepted.
`tts`, `realtime`	`default_voice`, `voices`	Used when `voice` is `null`. Live rosters: voices.
`tts`	`supports_voice_settings`	Whether `stability` and `similarity_boost` are allowed (ElevenLabs).
`tts`	`expressive`	Present: the model speaks delivery tags. See expressive delivery.
`realtime`	`supports_instruction_update`	`false`: the agent cannot have handoffs.

A providers entry with browse: "search" (OpenRouter) is not in the arrays; its searched_kinds say which kinds you search for.

The model slots

Slot	Fields
`stt`	`provider`, `model`, `fallback`
`llm`	`provider`, `model`, `reasoning_effort`, `priority`, `builtin_tools`, `hosts`, `fallback`
`tts`	`provider`, `model`, `voice`, `voice_name`, `speed`, `expressive`, `stability`, `similarity_boost`, `fallback`
`realtime`	`provider`, `model`, `voice`, `voice_name`, `speed`

voice_name is a dashboard label and is never sent to the provider. A voice or video agent runs either the stt → llm → tts cascade or one realtime model; setting realtime clears the other three. See realtime models. For fallback, see model fallbacks.

Choosing

Language first. A model that publishes languages must cover the agent’s language, and a language_required model refuses Auto. See language.
Speech-to-text decides turn-taking. Streaming models end turns on their own detector; batch models are cheaper, add a round-trip, and are the only ones that can use the end-of-turn model. See speech-to-text and turn detection.
On a call, thinking is silence. Keep reasoning_effort at the model’s fastest value unless the answer needs more.
Mix providers freely. The three cascade slots are independent.

A model whose channel does not include the agent’s channel is refused. Some language models are text only.

`llm.reasoning_effort`

One of none, minimal, low, medium, high, and it must be in the model’s reasoning_efforts. Unset means the first (fastest) value. A model with an empty list refuses any value. The names do not order the same way at every vendor, so read the catalog’s order rather than the words. Changing llm.model without sending reasoning_effort drops the old value and the new model starts at its fastest. llm.fallback and analysis.model carry their own, checked against their own model. On a voice or video agent every second of reasoning is silence. On a text agent or an agent task, nobody hears the wait.

`llm.priority`

true asks the provider to run this model in its priority lane, which shortens queueing when the provider is busy. It does not make the model think faster and does nothing for speech or avatar models. The lane is best-effort; you pay the premium even when a turn is served at standard speed.

Cost: the entry’s priority.pricing replaces its standard token rates for every turn, between 1.75x and 2.5x. Only the language model’s token spend moves; the platform fee does not.
Billing follows the request. Turns are metered at the priority rate because the agent asked for the lane. Where the entry’s priority.confirms is false (Gemini), the provider never reports which tier served the turn, so a silent downgrade is still metered at the priority rate.
Reporting: priority lines are tagged priority in a call’s cost breakdown and totalled as priority_cost in observability. See costs.

Refused on save:

Setting	Error
`llm.priority` or `llm.fallback.priority` on a model whose `priority` is `null`	`the model '…' has no priority lane - turn it off, or pick a model that offers one`
`analysis.model.priority`, on any model	`the call analysis model cannot use the priority lane - …`

There is no priority on a realtime model or on OpenRouter models. Try it on one call with agent_override (per-call configuration), and compare the LLM first-token latency tail on real calls before leaving it on.

`llm.builtin_tools`

Tools the model provider runs on its own servers mid-turn — web search, X search, a code sandbox, a provider-hosted file store. The provider folds the result into its reply; Talqing never sees the call. They are not Talqing tools: nothing to create, publish or attach.

{
  "llm": {
    "provider": "openai",
    "model": "gpt-5.6-luna",
    "reasoning_effort": "none",
    "builtin_tools": [
      { "type": "web_search", "config": { "allowed_domains": ["northwind.example"], "search_context_size": "low" } }
    ]
  }
}

Each entry is {type, config}. Valid types and config keys are the model’s builtin_tools[].type and options[].key; an empty config means the provider’s defaults. builtin_tools is a list, so a PATCH replaces it whole.

The provider bills each search or run on your key, per its price_note, and the editor’s cost estimate does not include it. The tool runs before the agent speaks, so on a call prompt the agent to say it is looking something up.

Refused on save:

a type the model does not offer, or the same type twice
a config key the tool does not declare, or a value of the wrong shape or length
a missing required option (file_search needs vector_store_ids)
both halves of a conflicts_with pair, such as allowed_domains with excluded_domains
one of your own tools or a handoff named the same as a provider tool

Changing the model drops tools the new model does not offer. file_search searches a store in your own provider account; Talqing only passes its id.

OpenRouter

One OpenRouter key reaches hundreds of tool-capable language models and a set of speech-to-text models from many labs. They are not in GET /v1/catalog; search them, then set model to the exact slug returned.

curl "https://api.talqing.com/v1/catalog/models?q=claude&limit=20" \
  -H "Authorization: Bearer $TALQING_API_KEY"

const page = await talqing.catalog.models.search({ q: "claude", limit: 20 });

page = talqing.catalog.models.search(q="claude", limit=20)

kind is llm (default) or stt. With no q, results are ordered by real-world usage. Page with cursor from next_cursor.

{ "llm": { "provider": "openrouter", "model": "openai/gpt-oss-120b", "hosts": ["groq", "cerebras/fp16"] } }

Not listed: :free and :batch variants, moving -latest aliases, and router slugs such as openrouter/auto. Use llm.fallback instead of a router.
Thinking: reasoning_efforts is what the model accepts, with none added wherever thinking can be switched off; it is the default.
Not available: builtin_tools and priority.
Routing: requests are sorted by latency and hosts that train on prompts are refused. Neither is configurable.
Price: search results show the cheapest host’s rate; your usage is priced from what OpenRouter reported charging.
llm.hosts restricts the model to the hosts you name; the fastest of them answers. Valid values come from GET /v1/catalog/models/hosts?model=<slug> (list_model_hosts over MCP). A bare host name covers all its endpoints (azure matches azure/us). Publishing warns about a host that no longer serves the model and refuses when none does. llm.fallback and analysis.model take their own hosts.
Speech-to-text: every OpenRouter STT model is batch, so its fallback must be batch too. No language is sent to it — it always detects — and host selection and the no-training preference do not apply.

openai/gpt-transcribe exists both as openai + gpt-transcribe (your OpenAI key) and openrouter + openai/gpt-transcribe (your OpenRouter key); they are separate selections.

tts-cache-router

tts-cache-router replays sentences your agents have spoken before, with the same voice and settings, from your router account’s cache. Set tts.provider to tts_cache_router and model to <provider>/<model> for any text-to-speech entry; voices, languages, speed and voice settings are the underlying model’s.

{ "tts": { "provider": "tts_cache_router", "model": "sarvam/bulbul:v3", "voice": "shubh" } }

The router account is yours: your provider keys are stored there, and Talqing holds only the router’s tcr_ key. Publishing checks the router account has a key for the voice’s provider.
A synthesized sentence is billed by the provider at its rate; a cached one by the router at providers.tts_cache_router.routes.tts.cached_per_character. The editor’s estimate prices every sentence as new.
Out of router credit, the agent cannot speak. Give tts a fallback on another provider if that matters.

Avatar and noise cancellation

avatar entries are for video agents; see video avatars. noise_cancellation entries are ai-coustics models billed to your own ai-coustics account; see audio processing.

Model fallbacks

A second provider per stage, and the rules it must satisfy.

Realtime models

One speech-to-speech model instead of the cascade.

Get started

Build

Guides

What the catalog returns

The model slots

Choosing

`llm.reasoning_effort`

`llm.priority`

`llm.builtin_tools`

OpenRouter

tts-cache-router

Avatar and noise cancellation

Next

Model fallbacks

Realtime models

​What the catalog returns

​The model slots

​Choosing

​llm.reasoning_effort

​llm.priority

​llm.builtin_tools

​OpenRouter

​tts-cache-router

​Avatar and noise cancellation

​Next

Model fallbacks

Realtime models

What the catalog returns

The model slots

Choosing

`llm.reasoning_effort`

`llm.priority`

`llm.builtin_tools`

OpenRouter

tts-cache-router

Avatar and noise cancellation

Next