Settings
Global app settings shared across all agents: identity, providers, MCP, channels, mesh, system prompt, usage, logs
On this page
Open Settings with the gear in the title bar, Edit → Settings… (ADF Studio → Settings… on macOS), or Cmd/Ctrl + ,. Settings are global and apply across all agents. Settings replaces the sidebar with its own navigation: Back to app returns to where you were, and Search settings filters the pages.
The sidebar has two groups (settings-scopes.md):
- Studio, the app on this computer: Appearance, Notifications, Updates, Privacy, About, Connections. These are kept by Studio (
studio-client-settings.json) and stay the same whichever server it connects to. - The server’s pages: Prompts, Agent templates, Providers, Packages, MCP servers, Skills, Channels, Files, Identity, Networking, Compute, Usage. These are the settings of the agent server (the ADF daemon). With the local server only, the group has no heading. Once a connection is saved in Connections, the group is headed Server with a picker of the server names (“name (Local)”, and each saved connection such as
box-1), and the pages show the settings of the server picked there, under a quiet header strip: “Server”, then the server’s icon and name. Settings opens on the server of the open agent (from an agent window: that window’s server), else the local server; the choice is not saved. A picked server that is not connected shows “Not connected to name.” with its controls disabled. With another computer picked, controls only its own computer can change (Remote access, owner identity, the firewall) say “Change on name.” The Studio pages do not change with the picker.
Saving
Settings save as you change them. There is no Save button, except in a dialog that creates something (a provider, an MCP server, a connection) and in the prompt editors (see System Prompt).
- A text or number field saves when you press Enter or leave it. Escape puts the saved value back.
- A field that refuses a value says why under it, and nothing is written. Numbers are never clamped or replaced with 0.
- After a write lands, Saved shows briefly in the page header.
- When the runtime refuses a write (for example, the daemon’s secret store is locked), the control goes back to the saved value and a notice reads “Not saved: reason”. It stays until you dismiss it. The provider, MCP server and channel lists keep your edit, and the row it concerns says why; the next change retries it.
- Removing a list entry that can be put back (a package, a catalog source, a manual peer, an execution target) shows Undo for 10 seconds instead of asking first.
- A risky action asks first, in one dialog whose button names the action: Replace owner (Import identity), Allow host access (Compute), Revoke (an approved host server), Stop (a container others use), Replace prompts (Auto-update), Clear usage, and a template’s Reset, Delete and file Remove.

Privacy
Studio sends no telemetry. Each request it or the runtime makes on its own has an off switch:
- Studio → Updates → Automatic checks (
updateChecksEnabled) — packaged builds ask GitHub Releases for a newer version 15 s after launch and every hour. Nothing downloads until you click the update badge. Off = Studio never contacts GitHub for updates. Check for updates checks now. - Server → Providers → Models (
providerChecksEnabled) — aGET /modelswith each configured provider’s key when Home loads, when the provider list first shows a provider, and when an agent review opens. Off = providers are contacted only when you click Test or an agent runs. - Server → MCP servers → Live catalogs (
remoteCatalogsEnabled) — fetch the current MCP server registry from GitHub when you open Settings → MCP servers (and the agent registry, which the current UI does not use). Off = only the copies bundled with the build and the last fetched copy. - Studio → Privacy → Spell-check dictionaries (Linux only,
spellcheckDownloadsEnabled) — a Download button. Linux spell check uses Hunspell dictionaries from Google’s CDN; nothing is fetched until you click it. After that, a newly added spell-check language downloads the same way. Windows and macOS use the OS spell checker and never download.
The first-party skill catalog is a default entry in Settings → Skills, fetched when you open the skill browser; remove it there to stop that request. Network traffic lists every connection.
Identity
The Identity tab shows the app-level identities that anchor ownership and trust. See Security and Identity for the full model.
Owner identity
Your user identity as a did:key DID, derived from a 12-word seed phrase generated on first launch:
- Back up seed phrase — reveals the 12 words (numbered for order, with a copy button) and asks you to confirm you’ve written them down. Until confirmed, a “Seed not backed up” badge shows.
- Import identity — enter a seed phrase from another computer to become the same owner there; agent files you own locally are restamped to the imported DID, and the result reports how many files were updated. Because the owner changes, Studio asks first; the button reads Replace owner.
- Previously used (migrated) owner DIDs are listed so you can see what older files were stamped with.
- Secret storage shows how Studio stores the seed phrase, its runtime keys and app-level MCP sign-ins in its own settings file (in Local mode, the copies it still holds from Inside Studio; the daemon keeps its own secrets). It is shown with a remote server picked too, and is then still about this computer’s Studio file, never the remote’s secrets: Encrypted with the system keychain, or Unencrypted if you chose that when Studio asked at launch (no keychain available). While unencrypted storage is chosen, a warning stays on this page, even once a keychain works. Encrypt with Keychain switches back once the keychain is available: every secret is encrypted and checked in one step, and your owner and runtime identity stay the same. If the keychain was chosen and is unavailable now, the group says that secrets cannot be read or saved until it is back. On Linux, a keychain means a Secret Service keyring (GNOME Keyring, KWallet) that is running and unlocked; see Owner secret storage.

Server key
Server key (“Identifies this server to other servers. Two servers never share one.”) is the server’s runtime DID. Two servers never share one, even with the same owner. Shows:
- A Delegation valid badge when the runtime holds a valid owner-signed delegation certificate (issuer and issue date shown below).
- The agent directory URL (
http://<host>:<port>/agents): the endpoint that other servers fetch to find the agent cards that this server serves. Each requester sees only what its visibility scope allows.
Agent identities
Per-agent DIDs and keystores are managed separately in the dock’s Agent → Identity tab; attestation publishing is toggled per agent in Agent → Config → Security.
Providers
Providers are the LLM services that power your agents. You need at least one configured provider before agents can think. The providers config section is on sys_update_config’s immutable deny list — agents can never write it, not even via approval; provider setup is always the owner’s (agents can still set their own model.provider and model.model_id).
An agent uses its own provider, else its template’s, else the server default. The server default is the provider marked Default on this page (Make default for new agents in its dialog), or the first one. In an agent’s Config, the Provider list groups the providers stored on the agent (On this agent) and the ones set up here but not stored on it (Runtime; they do not go with the file).
Adding a Provider
- Go to Settings > Providers
- Click Add provider. A picker lists everything you can connect, grouped as Subscriptions (Claude, ChatGPT, Grok — sign in, no key), APIs (Anthropic, OpenAI, OpenRouter, Gemini, xAI, Mistral, DeepSeek, Groq, Cerebras, Together, Fireworks, and other hosted endpoints), Local (LM Studio, Ollama, vLLM, llama.cpp, …), and Other (any OpenAI-compatible URL).
- Pick a tile. The provider is created with its base URL prefilled and a default name (
Groq, thenGroq 2, … — rename it freely; you can add the same service more than once for separate accounts) and its configure modal opens.
Every provider row opens the same modal, in two parts:
App default — what an agent gets when it selects this provider.
| Field | Description |
|---|---|
| Name | Display name for this provider configuration |
| Base URL | Only shown for OpenAI-compatible entries; prefilled from the tile |
| API Key / Account | Your key for the service, or the sign-in state for subscription providers |
| Default Model | The model to use when an agent doesn’t specify one. Fetch models lists what the endpoint offers |
| Advanced | Request delay (milliseconds before each call, for rate limits) and Request parameters (extra JSON fields merged into every request body) |
Agent overrides — agents that use their own key, model, request parameters, or delay for this provider. Add agent override picks an agent from the tracked folders; expand a row to set its fields; Remove deletes the agent’s copy (and its key) so it follows the app values again. Badges name what differs. The row chip counts these overrides.
Under the hood every override is a copy of the provider inside the agent’s .adf (see Per-ADF Provider Configurations). Studio also puts an unchanged, key-less copy into every agent it creates; those are not overrides and stay hidden behind a Show N agents with an unchanged copy link.
Most tiles are the same OpenAI-compatible runtime with a different base URL and logo; the modal says which API it speaks under the status line. The underlying types are anthropic, openai, openai-compatible, openrouter, claude-subscription, chatgpt-subscription, and grok-subscription.
Provider Types
Model requirement: tool calling. ADF gives the model every capability it acts through — built-in tools, messaging, memory and file writes, MCP tools, spawning agents — as native tool (function) calls. There is no text-based fallback. Any provider and model that supports tool calling gets every tool-driven capability, including local open-weight models served through Ollama, LM Studio, vLLM or llama.cpp. A model without tool calling cannot run a standard agent: every request carries the enabled tools’ definitions, which such models typically reject (Ollama answers “does not support tools”) — it can only chat if every tool is disabled. Triggers, timers, lambdas and middleware run in the runtime and keep working regardless of the model. Image, audio and video input need a multimodal model, and reasoning controls depend on the provider. When choosing a local model, pick one whose model card lists tool or function calling support (older llama.cpp server builds also need
--jinja).
Anthropic — Claude models. Uses the Anthropic API format.
OpenAI — GPT models. Uses the OpenAI API format.
OpenAI-compatible — Any service that implements the OpenAI API format. The picker offers named tiles for the common ones (Gemini, xAI, Mistral, DeepSeek, Groq, Cerebras, Together, Fireworks, Perplexity, Cohere, Hugging Face, NVIDIA NIM, Vercel AI Gateway, Cloudflare Workers AI, Azure OpenAI, DeepInfra, SambaNova, Nebius, Hyperbolic, Novita, Baseten, Scaleway, Venice, kluster.ai, Moonshot, Z.ai, Qwen, MiniMax, Inception) and for local servers (LM Studio, Ollama, vLLM, llama.cpp, LiteLLM, Jan, LocalAI, text-generation-webui), each with its base URL prefilled. Anything else goes through the generic OpenAI-compatible tile with a base URL you enter.
OpenRouter — Access to OpenRouter’s model catalog (e.g. anthropic/claude-sonnet-4, deepseek/deepseek-r1). Uses the official OpenRouter provider, so reasoning is normalized natively and full reasoning_details are returned and round-tripped across tool calls (see Reasoning). Just add your sk-or-… API key; the base URL defaults to OpenRouter.
ChatGPT Subscription — Use your existing ChatGPT Plus or Pro subscription to power agents at a flat monthly rate instead of per-token billing. This provider authenticates via OAuth (no API key needed) and uses the ChatGPT Responses API backend.
Setup:
- Add a provider and pick ChatGPT under Subscriptions
- Click Sign in with ChatGPT — this opens your browser for OAuth authentication
- After signing in, the provider shows your email and authentication status
- Select a model from the dropdown (e.g.,
gpt-6-sol,gpt-5.6-luna)
Notes:
- Authentication is app-wide within Studio — all agents using this provider share the same session. A Studio in Inside Studio mode and the daemon keep separate sessions; in Local mode the session moves to the daemon (see Where subscription sessions are stored)
- Tokens are encrypted at rest via the system keychain (macOS Keychain, Windows DPAPI, etc.)
- Token refresh is automatic; if your session expires, click Sign In again
- The API key and Base URL fields are not used — authentication is handled entirely via OAuth
- These models are reasoning models — temperature and topP settings are not supported and are automatically omitted
Available models: gpt-6.1-sol, gpt-6-astra, gpt-6-sol, gpt-6-luna, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5
Note on gpt-5.6 reasoning traces: the codex backend ships reasoning summaries in an “experimental” headline-only format — each section is a bold headline whose body is an empty <!-- --> placeholder that is never filled server-side. adf strips the placeholders and shows the headlines; the full chain-of-thought is not available from the backend.
Grok Subscription — Use your SuperGrok or X Premium subscription to power agents with xAI’s Grok models, no API key or metered console billing needed. Authenticates via xAI’s OAuth device-code flow against auth.x.ai; requests go to the standard xAI API (api.x.ai/v1) with the OAuth bearer token.
Setup:
- Add a provider and pick Grok under Subscriptions
- Click Sign in with Grok — your browser opens to xAI with a short device code pre-filled
- Confirm the code shown in adf matches the one in the browser and approve access
- adf detects approval automatically and shows your signed-in status
- Select a model from the dropdown (e.g.,
grok-4.5,grok-4.3)
Notes:
- Authentication is app-wide within Studio — all agents using this provider share the same session. A Studio in Inside Studio mode and the daemon keep separate sessions; in Local mode the session moves to the daemon (see Where subscription sessions are stored)
- Tokens are encrypted at rest via the system keychain (macOS Keychain, Windows DPAPI, etc.)
- Token refresh is automatic; if your session expires, click Sign In again
- xAI decides which accounts are eligible for OAuth API tokens — if sign-in succeeds but requests fail with 403, check your subscription tier on xAI’s side (or use an
openai-compatibleprovider with aconsole.x.aiAPI key instead) - The device-code flow needs no localhost callback, so it also works over SSH against the daemon (
POST /auth/grok/startreturns the code and verification URL)
Available models (fetched live from xAI when signed in; fallback catalog): grok-4.5, grok-4.3, grok-build-0.1, grok-4.20-0309-reasoning, grok-4.20-0309-non-reasoning
Claude Subscription — Use your Claude Pro or Max plan to power agents with Claude models. adf never handles Claude credentials: sign-in runs through your installed, unmodified Claude Code (claude auth login), and requests go through the official Claude Agent SDK, which drives that Claude Code binary. Usage draws from your plan’s limits as Agent SDK (third-party) usage.
Requirements: Claude Code 2.1.248 or newer, installed per Claude Code setup. adf looks for claude in the usual install locations and on PATH; set ADF_CLAUDE_CODE_PATH to use a specific executable.
Setup:
- Add a provider and pick Claude under Subscriptions
- Click Sign in with Claude — Claude Code opens your browser to Claude’s sign-in page. If the page shows a code instead of finishing on its own, paste it into adf
- After signing in, the provider shows your email and plan
- Select a model from the dropdown (e.g.,
claude-opus-5-5,claude-sonnet-5-5)
Notes:
- The session is Claude Code’s own and is shared with your normal Claude Code use on that machine. Signing in from Studio, the daemon or a terminal
claude auth loginsigns in all of them; signing out from adf also signs Claude Code out - Claude Code MUST be signed in with a Claude plan. A Claude Code session signed in with an Anthropic Console account is reported as signed out
ANTHROPIC_API_KEY,ANTHROPIC_AUTH_TOKEN,CLAUDE_CODE_OAUTH_TOKENandANTHROPIC_BASE_URLare removed from Claude Code’s environment, so usage is never billed to an API key by accident- adf stays the agent: tools, permissions and history are adf’s. Claude Code’s built-in tools are disabled; it relays the model’s tool calls back to adf through an in-process MCP bridge
- Differences from the Anthropic (API key) provider: temperature, top-p, Max tokens and Custom Parameters are ignored (Claude Code sizes each response to the model’s own output limit, which also covers thinking); images in tool results are passed, audio and video are replaced by a one-line note
- Claude Code adds model input of its own that adf cannot turn off: the system prompt prefix “You are a Claude agent, built on Anthropic’s Claude Agent SDK.”, and reminders with the environment (working directory, platform, shell), the model name and knowledge cutoff, the signed-in Claude account’s email address, and the date. adf records each of these in the loop verbatim as an Added by Provider context entry. Agents that talk to third parties SHOULD NOT use this provider if the owner’s email must stay private
- adf turns off the rest: Claude Code’s token-countdown reminder, CLAUDE.md and auto-memory loading, skills, plugins, hooks and user settings from
~/.claude - Dynamic instructions are delivered when they change and stay in the conversation (other providers resend them on every request). During a tool loop Claude Code wraps them as
PostToolBatch hook additional context: …in a system reminder - When a new Claude Code session has to resume in the middle of a tool loop, adf sends the prompt
Continue.; it is recorded in the loop - The fallback sign-in URL lets a remote daemon sign in from any browser (
POST /auth/claude/start, thenPOST /auth/claude/codewith the code shown)
Available models (reported by Claude Code for the signed-in plan; fallback catalog): claude-opus-5-5, claude-sonnet-5-5, claude-fable-5-1, claude-haiku-4-5
Where subscription sessions are stored
adf does not store the Claude session. It lives in Claude Code’s own credential store, shared by every surface on the machine. The rest of this section covers ChatGPT and Grok.
Sessions are per-surface: Studio and the daemon each own a token file and never write to the other’s.
| Surface | File | At rest |
|---|---|---|
| Studio (Electron) | <userData>/<provider>/auth.json | OS keychain via safeStorage (macOS Keychain, Windows DPAPI) |
| Daemon / CLI (plain Node) | <userData>/<provider>/auth.daemon.json | AES-256-GCM under <userData>/credential.key |
<provider> is chatgpt-subscription or grok-subscription.
Signing in to Studio in Inside Studio mode does not sign in the daemon. They are separate sessions — sign in to each surface once. See adf auth login for the daemon side, including the remote-daemon case. At the first launch in Local mode, Studio moves its session file to auth.daemon.json (and back at the first launch Inside Studio), so one session follows the mode; see Studio backend › What moves.
Why split them? safeStorage is only callable from inside Electron, so anything it encrypts is opaque to a plain-Node daemon. Sharing one file would mean dropping Studio to an encryption scheme the daemon can also open — trading the OS keychain for a key file sitting beside the ciphertext. The split keeps Studio’s keychain protection intact.
The daemon still encrypts. No keychain access is not a licence to store bearer tokens in the clear, so the daemon falls back to AES-256-GCM under credential.key — a 32-byte key generated on first use with mode 0600. Be clear about what that buys: it protects against other users on the machine and against a copied token file, but not against code already running as you, which the keychain does. On Windows, Node’s mode only toggles the read-only attribute; the real protection is the NTFS ACL on your profile directory.
Two safety rules follow from the split:
- A
safe:payload the daemon cannot decrypt is never overwritten or adopted — it belongs to Studio, so the daemon reports signed-out rather than guessing. A plaintextauth.jsonfrom a pre-split build is adopted once intoauth.daemon.json. - A write that would replace keychain-encrypted tokens with the weaker key-file encryption is refused outright. Log out first, so the downgrade is deliberate.
Within a surface, the daemon and every adf CLI invocation share one file and may refresh concurrently. Since OpenAI rotates the refresh token on every refresh, each re-reads before spending its copy and adopts a newer session rather than invalidating the other’s.
Rate Limits and Provider Status
ChatGPT subscriptions have usage limits tracked across two rolling windows: a primary (5-hour) window and a secondary (7-day) window. Usage is measured as a percentage — the exact formula is determined server-side by OpenAI.
Agents can monitor their rate limit status by calling sys_get_config({ section: "provider_status" }), which returns metadata captured from the last API response:
| Field | Description |
|---|---|
planType | Subscription tier (plus, pro, etc.) |
primaryUsedPercent | Percentage of primary (5-hour) window consumed |
primaryResetAfterSeconds | Seconds until the primary window resets |
primaryResetAt | Unix timestamp when the primary window resets |
primaryWindowMinutes | Duration of the primary window (typically 300) |
secondaryUsedPercent | Percentage of secondary (7-day) window consumed |
secondaryResetAfterSeconds | Seconds until the secondary window resets |
secondaryResetAt | Unix timestamp when the secondary window resets |
secondaryWindowMinutes | Duration of the secondary window (typically 10080) |
creditsBalance | Remaining purchased credits |
creditsHasCredits | Whether the account has purchased credits |
activeLimit | Which limit is currently active (e.g. codex) |
This enables self-managing agents — for example, a lambda can check primaryUsedPercent before expensive operations and defer work until the window resets. When the usage limit is reached, the error surfaces immediately (no retries) with the reset time in the error message
Custom Parameters
Every provider type supports custom key-value parameters (set per-agent in Agent > Config > Model, or as provider-level defaults). Each parameter is injected directly into the request body sent to the provider.
- Values are parsed as JSON when possible (so
{"effort":"high"}becomes an object), otherwise sent as a string. - Injection happens last, so custom parameters override anything the app set automatically — including the reasoning options below.
- A parameter with an empty value removes that key from the request entirely.
Use them for provider-specific features (sampling knobs, routing preferences) or to bypass the unified reasoning mapping (see below).
For chatgpt-subscription, the separate Provider Parameters (
provider_params) field is also forwarded asproviderOptions.openaito the AI SDK; the key-value parameters above are injected into the raw request body.
Reasoning (Thinking)
Reasoning is configured once, provider-agnostically, in Agent > Config > Model > Reasoning:
- Effort —
minimal→x-high(or Off) - Max tokens — optional explicit reasoning budget (takes precedence over effort)
- Exclude — reason internally but don’t return the trace
- Preserve — carry reasoning across tool-call turns
The app translates this to each provider’s native format:
| Provider | Sent as | Notes |
|---|---|---|
| Anthropic | thinking: { type: 'enabled', budget_tokens } | Budget = max tokens, or derived from effort (clamped 1024–128000). Temperature/top-p are omitted (Anthropic requirement). |
| OpenAI | reasoning: { effort, summary } | summary defaults to auto. |
| ChatGPT Subscription | reasoning: { effort, summary } | Same as OpenAI (Responses API backend). |
| Grok Subscription | reasoning_effort | Effort is clamped to xAI’s none/low/medium/high scale (minimal→low, xhigh→high). Only some Grok models accept an effort level (e.g. grok-4.3: none/low/medium/high; grok-4.5: low/medium/high) — others reject it; turn Reasoning off for those. Models that return reasoning_content traces have them displayed; the Grok 4 family keeps its chain-of-thought server-side. |
| Claude Subscription | Agent SDK thinking / effort | Max tokens → fixed thinking budget; otherwise adaptive thinking at the chosen effort (minimal→low). Exclude hides the trace. Off disables thinking. Summarized traces are displayed. |
| OpenRouter | reasoning: { effort | max_tokens, exclude } | Returns full reasoning_details; Preserve round-trips them (including encrypted blocks) across tool calls. |
| OpenAI-compatible | (not auto-mapped) | Reasoning support varies by server — set it via Custom Parameters. |
Field support:
- effort — all providers (converted to a token budget for Anthropic).
- max_tokens — direct budget for Anthropic/OpenRouter; converted to an effort level for OpenAI. Wins over effort.
- summary (
auto/concise/detailed) — OpenAI / ChatGPT-subscription only. This is what makes OpenAI reasoning visible; without it the model is billed for reasoning tokens but returns no trace. - exclude — OpenRouter only.
- preserve — OpenRouter only (other providers manage reasoning continuity internally).
Reasoning traces shown in the loop are provider-side summaries, not the full hidden reasoning. Encrypted reasoning blocks are surfaced but labeled as not human-readable (retained only for tool-call continuity).
Overriding / bypassing the mapping
To send an exact reasoning payload yourself, use Custom Parameters — they are injected last and override the auto-mapped values. The cleanest pattern:
-
Set Reasoning to Off in the model config (stops auto-injection).
-
Add the raw parameter your provider expects, for example:
Provider Key Value OpenAI / ChatGPT-subscription / OpenRouter reasoning{"effort":"high","summary":"detailed"}Anthropic thinking{"type":"enabled","budget_tokens":8000}
You can also leave Reasoning on and override a single field, or set a key’s value to empty to remove something the app added.
Per-ADF Provider Configurations
Each ADF file can store its own copy of a provider independently of the app-wide settings. This allows agents to ship with embedded API keys, custom models, and provider-specific parameters. At runtime, when providers[] in the agent config contains the selected provider id, that entry is used for every field it carries, with the key read from the agent’s adf_identity. If the agent’s copy has no key, the app-wide provider with the same id supplies the key (and nothing else) — only when the agent’s copy targets the same endpoint (same type and, for types that honor a base URL, the same base URL). New agents created in Studio get exactly such a key-less copy of the default provider, which is why they work out of the box with the app key. The headless daemon resolves providers the same way, using its own settings file as the “app-wide” side.
Per-ADF provider configs are managed from:
- Settings > Providers — Open a provider and use Agent overrides to add an agent and set its API key, default model, request delay, and custom parameters.
- Agent → Config — The agent’s configuration panel shows which provider is being used and whether it has an override.
Credentials are stored in the ADF’s adf_identity table (encrypted at rest), mirroring the pattern used for MCP server and channel adapter credentials. ADF files with stored provider configurations will continue to work independently, even if the provider is not listed in the app-wide settings.
MCP Servers
MCP servers are managed on Settings → MCP servers. This configuration is app-level, not agent-reachable; agents request changes from their principal. See MCP Integration for full details.
Status Dashboard
From Settings → MCP servers:
- Add MCP Server — One button opens the configuration modal: pick a known server from the curated quick-add cards (OAuth servers labeled, prerequisites called out) or configure a custom/remote server; every option — package, args, env vars, run location, auth flow, credential files, agent availability — lives in the same form
- Connect — The modal’s verify button runs the real pipeline (credential files, OAuth browser flow when declared, tool discovery) and shows the discovered tools or the server’s own error output; unconnected servers show a Not verified badge
- Configure — Reopens the same modal for any server
- Reconnect / Re-authorize — Re-runs the connect pipeline for a saved server (re-auth shown for OAuth servers)
- Available to agents — Per-server toggle letting agents attach the server themselves (via
mcp_install); defaults on for container/remote, off for host - Logs — View per-server logs including tool call history
- Remove — Delete the server and its installation
- Credentials — Manage API keys and secrets per server (app-wide or per-agent) from the configure modal
Server Configuration
| Field | Description |
|---|---|
| Name | Server display name |
| Transport | Connection type: stdio (local process) or http (remote Streamable HTTP endpoint) |
| Runs on | Where the server executes: Host (default for Settings installs — runs on the host machine with your user account’s access, driven by your agents; auto-added to the host-approved list) or Container (shared compute container — isolation upgrade, requires Podman) |
| Command | Command to start the server (stdio) |
| Args | Command arguments (one per row, supports ~ expansion) |
| Environment Variables | Variables passed to the server process |
| Tool Call Timeout | Per-server timeout in seconds (default: 60) |
Channel Adapters
Channel adapters connect external messaging platforms to ADF agents. Manage them from Settings > Channels — that is the tab name; “adapter” is the runtime term for the code behind each channel. Telegram, email, Discord, Slack, and WhatsApp are built in and always available; each is connected per agent.
The Channels page
Each channel is a row listing the agents connected to it, one chip per agent with a live status dot (connected, connecting, error, or not running). When nothing is connected yet the page opens with a tile per channel.
- Connect an agent — pick an agent from your tracked folders, paste the credentials the form asks for (a Where to get this panel walks through obtaining them), and click Connect. Credentials are written to that agent’s
adf_identityand the channel is enabled in the agent’s config, which starts the adapter if the agent is running. - Click a chip — edit that agent’s credentials, see the adapter’s last error, or Disconnect (removes the config and the stored credentials).
- Logs — per-adapter log (up to 500 entries).
There is no app-wide credential store for channels. Adapters run inside each agent, so one bot token used by two agents would put two pollers on the same bot (Telegram rejects the second outright). One bot, one agent.

Available Adapters
| Adapter | Built-in | Required Credentials | Notes |
|---|---|---|---|
| Telegram | Yes | TELEGRAM_BOT_TOKEN | Bot token from @BotFather |
| Yes | EMAIL_USERNAME, EMAIL_PASSWORD | IMAP/SMTP; use app-specific password | |
| Discord | Yes | DISCORD_BOT_TOKEN (+ optional DISCORD_APPLICATION_ID) | Bot token from the Discord developer portal |
| Slack | Yes | SLACK_APP_TOKEN, SLACK_BOT_TOKEN | Socket Mode — no public endpoint needed |
| Yes | (none — QR pairing) | Personal account via Baileys; scan QR from the agent’s files. Unofficial protocol — use a non-critical account |
Every connection is per-agent config under adapters plus credentials in that agent’s adf_identity. Connecting an agent from the Channels page writes both; the agent’s config panel edits the same adapters block. See Messaging > Channel Adapters for full details.
Registered ≠ active. Built-in adapters are always registered by the runtime, but that only makes them available — it does not start them for any agent. An adapter runs for an agent only when
adapters[<type>].enabled === truein that agent’s config. And enabling the adapter alone is not enough for inbound messages to wake the agent: that also requiresmessaging.receive: trueand thetriggers.on_inbox.enabled: truetrigger. Missing either of the latter two is the most common reason a correctly-credentialed adapter connects but the agent never responds.
Security Guard & Locked Fields
A small set of per-agent security.* fields are guard toggles: they decide what the runtime allows or forces, so an agent can never write them itself. Unlike ordinary capability toggles (which an agent may request through a HIL approval), these are hard-denied to sys_update_config with no approval path — only the owner can change them, from the agent’s config panel.
| Field | Default | Effect |
|---|---|---|
security.allow_unsigned | true | Whether inbound messages without a valid signature are accepted. |
security.require_middleware_authorization | true | Whether messaging/fetch middleware lambdas must come from authorized files. |
security.middleware | — | Inbox/outbox middleware pipeline lambdas. |
security.fetch_middleware | — | Middleware chain applied to sys_fetch requests. |
A second tier is locked by default rather than hard-denied: security.allow_local_fetch (the sys_fetch/ws_connect SSRF escape hatch — default false; loopback is allowed by default, and when this is true private/LAN/CGNAT destinations are also permitted except the local ADF daemon control API and cloud-metadata/link-local addresses, which stay blocked regardless) and the stream_bind capability gates are locked by default in the runtime (for every agent, existing and new). An agent’s write is denied but surfaces as a protection request the owner can approve as a one-time override — or the owner removes the lock in the config panel.
Networking
Settings → Networking is about agent messaging: the mesh, which agents other computers can reach, the networks you allowed and the agent servers found. Other devices that use this server (remote access) are in Connections.
The page has, in this order: the status card, Sharing (Mesh, Network, Agents), Networks, Servers and Advanced (closed until you open it).
Network status
The status card has one fact per line, each with a state dot:
| Line | Value |
|---|---|
| Mesh | On or Off |
| Network | One line for each network this computer is on: “Wi-Fi (192.168.1.0/24) · Allowed”, ”· Not allowed”, or ”· Not identified”; “None” with no network |
| Shared | The number of agents with lan or public visibility, for example “3 agents” |
With another computer picked in the Server picker, the card has no Network line.
Nothing listens beyond 127.0.0.1 on a network until you allow it, once per network, the same on every OS (details: Studio backend › Network status). For each network you are on that is not allowed, the card shows Allow and what waits for it:
| Line | When |
|---|---|
| “Agent sharing paused on network.” | Network is on, or an agent has lan or public visibility |
| “Remote access paused on network.” | Remote access is on (Connections → Devices) |
| “Remote access and agent sharing paused on network.” | Both |
| “agent-1 is public.” | Under the paused line when an agent has public visibility |
| “Public network. …” | Under the line when Windows calls the network Public, or on macOS and Linux, which do not say |
Allow is the only place on this page that gives consent. An unidentified network has no Allow: nothing can listen there. When a firewall block is known, the card says how to fix it.
Unidentified network
Studio identifies a network by its router. When it cannot read the router, the network is “Unidentified network”. The status card and Networks say why, in one sentence, with Help (this section). Hold the pointer on Help to see the step that failed. The same line is in main.log ([Networking]) and in the daemon log ([remote-access]).
| Reason | What to do |
|---|---|
| “It cannot read the route table.” | The command that reads the route table failed (macOS /usr/sbin/netstat, Windows route, Linux /proc/net/route). Send the log line with a bug report. |
| “It cannot find the router address.” | This interface has no default route. Connect it to a network with a router. A link without a router (a cable between two computers) cannot be allowed. |
| “It cannot read the address table.” | The command that reads the ARP table failed (macOS /usr/sbin/arp, Windows arp, Linux /proc/net/arp). Send the log line with a bug report. |
| “The router does not answer.” | The router gave no MAC address after 3 tries. Some guest networks and hotspots block this. Use another network, or use Tailscale. |
| “It cannot find the subnet.” | The interface has no netmask. Reconnect to the network. |
You cannot allow an unidentified network. When the router answers, the card shows Allow. Why there is no Allow: Remote access › Consent per network.
Sharing
| Row | Effect | Setting |
|---|---|---|
| Mesh | Agents on this server send messages to each other. | The mesh and its mesh server, now. “Off stops agent messages, agent websites, agent APIs and messages from other servers.” (tooltip). Kill in the status bar also turns it off. |
| Network | Other computers on allowed networks can reach the agents that you share. | meshLan. Listens on this computer’s private-network and Tailscale addresses as well as 127.0.0.1, only on allowed networks; the addresses follow network changes within 10 seconds. A running server restarts on a change. MESH_HOST overrides it. |
| Agents | “N shared”, each agent with its visibility (LAN or Public). The name opens the agent’s window. | Read only. Visibility is set in Agent → Config → Messaging (Visibility tiers). |
An agent with lan or public visibility turns on the same listening as Network. A public agent never binds every interface (0.0.0.0) by itself: it needs the same consent per network, and the status card names it until you allow the network. Only MESH_HOST=0.0.0.0 binds every interface; that is the operator’s choice, for example on a server. A server with only a public address has no network to allow: while a public agent listens on this computer only, the daemon log, adf daemon status and the status card say “Public agents listen on this computer only. No network is allowed. On a computer with only a public address, set MESH_HOST=0.0.0.0. Then restart the server.” A device paired with this computer that changes an agent’s visibility gets no listener without your consent either.
The switches, the port and the binding are app-level, not agent-reachable; agents request changes from their principal.
Networks
“The networks where this server can listen. You allow each network one time.” The networks you allowed, each with Remove, which closes its listeners at once; the network you are on now has the Current badge. With none: “None” and “To allow a network, use Allow in the card above.” The mesh and remote access use the same list (allowedNetworks in remote-access.json). With another computer picked in the Server picker: “Change on name.”
Servers
“Agent servers on your networks, on your tailnet, or at an address that you add.” One list of the agent servers found (each one’s mesh), with how it was found:
| Badge | Found by |
|---|---|
| LAN | mDNS on this network |
| Tailnet | The Tailscale sweep (Advanced → Tailscale, tailnetDiscovery) |
| Address | An address you added (meshManualPeers), with ✕ to remove it (Undo in the toast) |
Each row shows the server icon, the host, its mesh address and, right-aligned, its agent count, or Unreachable when its directory did not answer (tooltip “The server sent an announcement. Its directory did not answer. Possible causes: a firewall, a wrong network interface, or a stopped mesh server.”). With none: “No server found.” Managed (tooltip “This Studio also connects to this server (Settings → Connections).”) means Connections also has that server under Remote servers: the fingerprint it announces is the one the connection was paired with, so a computer saved under its Tailscale https name is Managed too. A server that announces no fingerprint is matched by host and daemon port, unless another server on that host announces the connection’s fingerprint. An address you added that nothing answers at yet is listed with “No answer”.
Address with Add adds one: host:port, [IPv6]:port, or a bare host, which uses the mesh port. An address with http://, a path or a port outside 1–65535 is refused under the field. Recheck (“Look on the tailnet and at the addresses again now.”) probes the tailnet and the addresses and fetches each directory again.
Advanced
Closed by default; nothing in it is hidden.
| Row | Content |
|---|---|
| Autostart | The mesh starts when the server starts (meshEnabled). The Mesh switch does not change it. |
| Port | The mesh port (meshPort, default 7295). Leaving the field changes nothing; Apply saves it and restarts a running server on it. A value outside 1–65535 is refused under the field. |
| Mesh server | Running or stopped, with the addresses it listens on (for example 127.0.0.1, 192.168.1.20, port 7295, or 127.0.0.1 only (no private network) on a network not allowed). |
| Tailscale | Look for agent servers on the computers of your tailnet (tailnetDiscovery). |
| Addresses | This computer’s LAN addresses and Tailscale state, and each interface address with Copy; a link while Network is on. |
| HTTPS | tailscale serve gives this server an https address on your tailnet (remote access over https): Enable or Disable, each confirmed with the exact command first. Otherwise one sentence with the cause: why remote access cannot be read (for example “Remote access needs Local as the connection (Settings → Connections).”, or the daemon’s error), “Needs Tailscale.” while Tailscale is not running, or “Tailscale did not answer.” when tailscale serve status failed. |
| Firewall | Whether other servers can reach the mesh port (“Other servers find this server. They see 0 agents. Add a firewall rule for the mesh port.” while a rule is missing; “The firewall rule exists. The mesh server does not answer on address.” when it is there but nothing answers). When a rule is missing, the exact commands to run in an administrator shell, with Copy and a link to LAN discovery › Firewalls. Studio never adds a firewall rule itself. |
| Endpoints | The agents serving on the mesh: handle, URL, Site (public folder served), route count, pattern count. “Mesh is off.” while the mesh is off. See HTTP Serving. |
With another computer picked in the Server picker, Networks, HTTPS, Firewall and Endpoints say “Change on name.”: they belong to that computer.
System Prompt
The system prompt is assembled dynamically from two parts: a base prompt and conditional tool instruction sections. Both are editable in Settings → Prompts.
Base Prompt (Global System Prompt)
Every agent gets the base prompt and the tool instructions before its own instructions, unless its System prompt setting is No base prompt or Bare (see the table below). It explains the ADF paradigm — the document workspace, mind.md, how triggers work, tone and style directives — without referencing any specific tools. Use the base prompt for:
- Explaining the ADF paradigm to models that may not be familiar with it
- Setting global behavioral rules
- Providing context that all agents should have
Each prompt editor holds a draft: typing changes nothing until Save, and Revert puts the saved text back. Agents read the saved prompts when they start. Reset shows while the saved prompt differs from the default; it saves the default at once and offers Undo. Reset all does the same for every prompt on the page. Auto-update replaces every prompt with the new defaults whenever an update ships them; off, customized prompts are not overwritten when the default evolves.
Per-agent composition. Each agent’s Instructions section has a System Prompt select with three settings. Each option shows its approximate token count (measured with {{path}} placeholders resolved, the same figures as the status-bar context breakdown), and the label shows the size of the system prompt as currently sent:
| Setting | Config | System prompt |
|---|---|---|
| Full | — | base prompt, the capability sections its enabled tools call for, runtime blocks (identity, inner loops, multimodal, autonomous), agent instructions |
| No base prompt | include_base_prompt: false | runtime blocks and agent instructions |
| Bare | bare_prompt: true | agent instructions and nothing else |
The select governs the static system prompt only. Per-turn dynamic instructions (inbox hints, context warnings, mesh updates, idle reminder) are gated solely by the four Dynamic Instructions checkboxes in the same section — see Auto-Injected Context. Before schema v30, Bare also silenced them; that migration ticked all four off for agents that were already bare, so their behaviour did not change. Tool schemas are unaffected in every setting — they travel with the API request, not the prompt — so a bare agent is still fully capable, just unbriefed. {{path}} placeholders you write into the agent’s own instructions still resolve. Locking the Instructions section locks all three fields.
A section whose text you blank in Settings is skipped entirely rather than emitted as an empty block.
Tool Instructions
Below the base prompt, the Tool instructions group lists conditional prompt blocks that are injected based on the agent’s enabled tools and features. Each section has an expandable editor with the same Save, Revert and Reset as the base prompt. Modified marks a saved section that differs from the default; Unsaved marks a draft.
| Section | Injected When |
|---|---|
| Tool Best Practices | Shell is not enabled — provides cross-tool workflow guidance (read before edit, fs_write modes, verify results) |
| Code Execution & Lambdas | sys_code or sys_lambda is enabled — explains the adf proxy object, single-argument rule, async/await requirements |
| ADF Shell | adf_shell tool is enabled — replaces Tool Best Practices with comprehensive shell syntax, command reference, tips, and environment variables |
| Multi-Agent Collaboration | messaging.receive is enabled — behavioral rules for responding to messages, using exact names, managing inbox |
| HTTP Serving | Any serving feature is configured (serving.public, serving.shared, or serving.api) — explains public folders, shared files, API route definitions, and lambda handlers |
When the adf_shell tool is enabled, the Tool Best Practices section is replaced by the ADF Shell section — they are mutually exclusive. All other sections are additive. Sections are joined with --- separators.
Most individual tools (fs_read, fs_list, db_query, etc.) are self-explanatory from their schema descriptions and do not need additional system prompt guidance. The tool instruction sections focus on cross-cutting concerns that cannot be conveyed through tool schemas alone.
Agent Templates
Settings > Agent templates lists the .adf files new agents are made from, edits the selected one in place, and sets which of them is the default. See Agent Templates for the three templates Studio ships, what a new agent carries over from one, and how to use a template someone else sent you.
Auto-Save
See Saving. Back to app closes Settings.
Appearance
Studio → Appearance has:
- Theme: Light, Dark or System.
- Agent avatars: Orbital or Emoji, in lists, the title bar and the Mesh view.
- Chat width: Comfortable or Full, for the chat when it is in the center.
- Font family and UI scale.
Usage
ADF Studio tracks token usage across all agents. View it in Settings → Usage. Home’s “tokens today” opens the same page.
Usage Breakdown
- Per-date statistics
- Per-provider breakdown
- Per-model breakdown
- Input and output token counts
- Total statistics
Managing Usage Data
- Download JSON saves a copy of the usage data.
- Clear history… deletes every token count, after a confirmation whose button reads Clear usage.
- Data is stored locally and not sent anywhere.
Tracked Directories
ADF Studio monitors directories for .adf files. When a new file appears in a tracked directory, it shows up in the sidebar.
Managing Directories
- Directories are auto-tracked when you create or open a file
- Track folder… (the sidebar’s folder button, or File → Track Folder…,
Cmd/Ctrl + Shift + O) adds one; Untrack folder… in a folder row’s right-click menu removes it - The sidebar shows a hierarchical tree of tracked directories and their files
Directory Actions
- Start all — Start all agents in a directory
- Stop all — Stop all agents in a directory
- Rescan (right-click the folder row) — Read the folder again
Studio
The Studio pages apply to this app on this computer: Appearance, Notifications (system notifications, the menu bar icon), Updates (automatic update checks), Privacy, About and Connections.
File Associations
ADF Studio registers itself as the handler for .adf files. Double-clicking an .adf file opens it in the app.
Multiple Instances
For development, you can run multiple ADF Studio instances with --instance=N. Each instance gets a separate user data directory and independent settings.
Bottom Panel (Logs & Tasks)
ADF Studio includes a VS Code-style Bottom Panel at the bottom of the main view, toggled from the Logs or Tasks buttons in the status bar. The panel has two tabs: Logs and Tasks, with a shared drag-to-resize handle.
Logs Tab
Displays structured log entries from adf_logs — including lambda trigger executions, sys_lambda results, API serving requests/responses, and runtime events.
- Level filtering — Filter by
debug,info,warn, orerror - Origin filtering — Filter by origin (e.g.,
timer,lambda,serving,adf_shell). The dropdown is populated dynamically from the origins present in the current log entries. - Structured columns — Each log entry shows timestamp, level, origin, event type, target, and message
- Expandable data — Click a row to expand and view the full JSON data payload
- Text filter — The Filter… box narrows the list
- Live — On by default: new entries appear every 2 seconds while the panel is open. Click it to pause; the panel then shows when it last read the logs
- Per-ADF — Logs reload automatically when navigating between ADF files
Log Entry Fields
| Field | Description |
|---|---|
level | Log level: debug, info, warn, error |
origin | Where the log came from (e.g., timer, lambda, serving, sys_lambda, adf_shell) |
event | The event type (e.g., on_timer, api_request, api_response, execute, result) |
target | The specific target (e.g., system:lib/router.ts:onMessage, lib/api.ts:handler) |
message | Human-readable log message |
data | Optional JSON data payload |
See Logging for details on log filtering configuration (default_level, per-origin rules, max_rows).
Tasks Tab
Displays async tasks from adf_tasks — tool calls that require human approval or long-running operations.
- Status filtering — Filter by
pending,pending_approval,running,completed,failed,denied, orcancelled - Expandable rows — Click a task to view its full arguments, result, or error details
- Live — Off by default; on, the list refreshes every 2 seconds while the panel is open
- Per-ADF — Tasks reload automatically when navigating between ADF files
Connection
Studio → Connections (“Servers and devices.”) is last in the Studio group. In Studio the runtime is an agent server (the ADF daemon). From top to bottom, the page has one Add, then three sections (Studio backend › Connection):
- Local server (“The agent server on this computer.”): name (Local) with its state, Details (pid, who started it, URL, version, key), its More menu (⋯, Inside Studio (legacy)), and Keep running after Studio quits (
keepDaemonRunning, default off). It is never listed under Remote servers. - Remote servers (“Agent servers on other computers that this Studio connects to.”): each saved connection (shared with
adf) with its state, address and fingerprint, and Remove in its More menu. The menu opens over the page, so the card never cuts it. - Devices (“Devices that can access name (Local).”): the Remote access switch and the devices that use the local server, each with Revoke (see Studio backend › Devices).
For a Studio with the local server only, Remote servers and Devices fold to their heading line, which keeps “None” or “Off” in view; a click opens them. The status bar then shows no server name, and Kill’s tooltip reads “Stops all agents and mesh”.
Add opens one dialog, titled Add, with two cards side by side, each with an icon (Studio backend › Add):
| Card | Help line | What it does |
|---|---|---|
| Connect | “Connect to a remote agent server.” | Lists the servers found on this network and your tailnet as picks, then Address, Code and Token, all visible: “Enter a code or a token. To get a code, click Add, then Share on the other server.” With a code, Studio shows the server’s fingerprint to check, then Pair. The connection is saved and connects. |
| Share | “Share this server.” | Share this server as (the name devices see, the runtime alias), consent first when remote access is off or this network is not allowed (one Allow), then a 6-digit code with its countdown (Renew once it is gone), and one table of this server’s addresses grouped by network, each row with its own Copy. The other computer enters the code; this computer still asks Allow device. Then “Approved: name.” A token shown once is under Token. Only in Local mode. |
On success the connection is saved and connects at once; the dialog shows Done. Studio does not restart. Remove asks first: “Removes the address and token from Studio and adf.”, and “Closes N agent windows.” when that server has agent windows open, then “Still listed on name; revoke it there.”; it then disconnects and forgets the connection.
| Choice | mode | Agents run in |
|---|---|---|
| Local | local | A background service on this computer (the ADF daemon), using Studio’s settings and agent files. The default. Each saved connection is connected too. |
| Inside Studio (legacy) | embedded | Studio. Removed in the next release. |
Connect on name (Local) (while Inside Studio runs) or on Inside Studio (legacy) saves the mode for the next launch. Studio does not restart; the page shows “Next launch: name.” with Restart. While Inside Studio runs, saved connections are listed with no state and connect at the next launch in Local mode.
A studio-backend.json saved by an earlier release with "mode": "remote" is migrated at the first launch of this release: it becomes "mode": "local", and that connection stays saved and connects (see Upgrading from remote mode).
Studio stores the choice in studio-backend.json in its user data directory (%APPDATA%\ADF Studio on Windows, ~/Library/Application Support/ADF Studio on macOS, ~/.config/ADF Studio on Linux) and reads it once at launch, so a change applies at the next launch. Without the file, Studio runs in Local mode: at that launch it saves "mode": "local" and moves its ChatGPT and Grok sessions, and its MCP sign-ins when the keychain can be opened, to the daemon, as any first launch in Local mode does (see Upgrading from 0.7.x). Deleting studio-backend.json is therefore not a way back to Inside Studio.
Keep running after Studio quits is the one quit setting (earlier releases showed it twice, as Background and as On quit → Keep running). Its row says what happens: “When you quit Studio, Studio stops the server and its agents.” (off), “When you quit Studio, the server and its agents keep running.” (on; the ADF CLI manages it, adf daemon stop), or “Studio does not stop this server when you quit Studio, because the ADF CLI started it.” Inside Studio does not show it.
- An address must be
https://, orhttp://to loopback (an SSH tunnel) or a Tailscale address (100.64.0.0/10,fd7a:115c:a1e0::/48). Any otherhttp://address needs the confirmation that the token is sent unencrypted. - Tokens are in the OS keychain (shared with
adf), sent only to their connection’s address, and never shown again. - Once a connection is saved, the status bar has one group per runtime, right of the version: its name, its state while it is not connected, its Mesh and its Kill, whose tooltip adds “on name”. With none saved, only a problem shows, in the state’s words.
Go back to running agents inside Studio
In Settings → Connections → Local server, choose Inside Studio (legacy) in the local row’s More menu, then Restart. This is the persistent way back: the next launch moves the ChatGPT and Grok sessions back and deletes the keychain copy of the runtime identity. MCP sign-ins move back except those the daemon had before the first switch; when that switch could not read the daemon’s keychain entries and a daemon had already run on these settings, only the ones Studio moved come back (see What moves during a switch). See Run agents inside Studio when the daemon does not work.
Run agents inside Studio for one launch
If Studio does not start in Local mode, set ADF_STUDIO_BACKEND=embedded for one launch. It overrides studio-backend.json and leaves the file unchanged. Nothing moves back: sign-ins and the runtime identity stay where the saved backend keeps them, so ChatGPT, Grok and MCP sign-ins held by the daemon are not available in that launch. Settings → Connections shows “Inside Studio (legacy) because ADF_STUDIO_BACKEND is set.” Do not use the variable as the way back; use Settings → Connections as above.
# Windows (PowerShell)
$env:ADF_STUDIO_BACKEND = 'embedded'; & "$env:LOCALAPPDATA\Programs\ADF Studio\ADF Studio.exe"
# macOS
ADF_STUDIO_BACKEND=embedded "/Applications/ADF Studio.app/Contents/MacOS/ADF Studio"
On Linux, set the variable in the terminal you start Studio from. The variable also accepts local; remote is read as local.
Keyboard Shortcuts
Cmd/Ctrl + , opens Settings. Help → Keyboard Shortcuts lists every shortcut; ADF Studio has the main ones.