Zed

Zed connects to Actualyze as an OpenAI-compatible provider. You declare the provider and its models in settings.json, and give Zed your API key through its settings page or an environment variable. The models then appear in the Agent Panel's model picker and drive the Zed Agent, the Inline Assistant, commit message generation and thread summaries.

#Before you start

• An Actualyze API key with the inference scope and read-write permission. Workspace Admins, Members and FinOps Managers who belong to a team can create one: in the Actualyze app, select API Keys under ADMIN in the sidebar (every role that can hold keys sees this page, not only admins), then select Create API Key. Keep the default Read & Write permission. The key's budget is the one your Zed usage draws down.
• The IDs of the models you want, with their context window and output limit. The Zed Agent edits files and runs commands through tool calls, so pick models that support tool calling.

#Install

Zed runs on macOS, Linux and Windows:

# macOS
brew install --cask zed
 
# Linux
curl -f https://zed.dev/install.sh | sh

On Windows, run winget install -e --id ZedIndustries.Zed or download the installer from zed.dev/download.

#Connect to Actualyze

Zed doesn't read the list of models your key can call, so you list each model yourself. Add the provider to Zed's settings file. Run zed: open settings file to open it; on Windows it lives at %APPDATA%\Zed\settings.json.

{
  "language_models": {
    "openai_compatible": {
      "actualyze": {
        "api_url": "https://app.actualyze.ai/openai/v1",
        "available_models": [
          {
            "name": "<model-id>",
            "display_name": "Display name",
            "max_tokens": 200000,
            "max_output_tokens": 64000,
            "capabilities": {
              "tools": true,
              "images": false,
              "parallel_tool_calls": false,
              "prompt_cache_key": false,
              "chat_completions": true
            }
          }
        ]
      }
    }
  }
}

• actualyze is the provider ID. It is the name the model picker shows, and Zed derives the API key's environment variable from it: ACTUALYZE_API_KEY.
• name is the model ID Zed sends: a catalog model ID or Virtual Model slug, exactly as Actualyze lists it. Don't add a provider/ prefix of your own.
• max_tokens is the model's context window and is required. Zed doesn't read it from Actualyze, so copy the real value. The Zed Agent uses it to decide when to compact a long thread.
• max_output_tokens is the model's output limit. Zed sends it as the per-response cap.
• Set capabilities.tools and capabilities.images to match the model. If you include a capabilities block, keep all four of tools, images, parallel_tool_calls and prompt_cache_key in it; Zed reports a settings error when one is missing. Leave the block out entirely to get Zed's defaults: tools on, images off, Chat Completions.

Add one entry to available_models for each model you want. To find the IDs and limits, open the Actualyze Model Catalog, or list the models your key can call:

curl -s https://app.actualyze.ai/openai/v1/models \
  -H "Authorization: Bearer <your-actualyze-api-key>"

Use each entry's id for name, context_window for max_tokens, max_output_tokens for max_output_tokens, capabilities.tool_use for capabilities.tools and capabilities.vision for capabilities.images. A null means Actualyze has no value for that field; take the limit from the model provider's documentation instead.

Then give Zed your API key, in one of two ways:

• Run agent: open settings to open the AI page of Zed's settings, open LLM Providers, find the actualyze provider and enter the key. Zed stores it in the system keychain.
• Set an environment variable in the environment Zed starts from, then restart Zed. A non-empty variable takes precedence over the keychain.

export ACTUALYZE_API_KEY="<your-actualyze-api-key>"

You can also add the provider from the settings window: on the LLM Providers page, select Add Provider, then OpenAI under Compatible APIs. The form asks for a Provider Name (it becomes the provider ID), the API URL and the API Key, then for each model its Model Name, token limits (Max Tokens is the context window) and capability checkboxes. The token fields come prefilled with example values; replace them with the model's real limits. Use Add Model for each further model. Zed writes the provider to settings.json and the key to the keychain.

#Reasoning models and the Responses API

Zed uses Chat Completions by default. For a model that needs the Responses API, set capabilities.chat_completions to false and Zed sends that model's requests to /responses. Recent OpenAI reasoning models reject tool calls combined with a reasoning effort on Chat Completions, so use Responses for them.

To turn on thinking for a reasoning model, add reasoning_effort to its model entry with a level the model supports, such as "high". Zed then shows a thinking toggle and effort levels for that model in the Agent Panel, and uses your value as the default effort.

#Claude models over the Anthropic API

Zed also has an Anthropic-compatible provider type. To call Claude models through Actualyze's Anthropic endpoint, add a second provider:

{
  "language_models": {
    "anthropic_compatible": {
      "actualyze-anthropic": {
        "api_url": "https://app.actualyze.ai/anthropic",
        "available_models": [
          {
            "name": "<model-id>",
            "max_tokens": 200000,
            "max_output_tokens": 64000,
            "capabilities": {
              "tools": true,
              "images": true,
              "prompt_caching": true
            }
          }
        ]
      }
    }
  }
}

Keep api_url ending in /anthropic; Zed appends /v1/messages itself. Its key variable is ACTUALYZE_ANTHROPIC_API_KEY, or enter the key on the LLM Providers page. If you include capabilities, keep all three fields. Only models with a route that speaks the Anthropic protocol work through this endpoint.

#Choose a model

Open the Agent Panel and pick a model under actualyze. Zed lists exactly the models in available_models. The model you pick is saved as agent.default_model.

The Inline Assistant, commit messages and thread summaries use that same model unless you set agent.inline_assistant_model, agent.commit_message_model or agent.thread_summary_model.

These settings cover Zed's own AI features. Edit Prediction has its own provider setting, and its OpenAI-compatible option needs a /completions endpoint that Actualyze doesn't serve. External Agents, such as Claude Agent and Codex, use their own configuration and don't read these settings: see the Claude Code guide and the Codex guide.

API keys are read on your local machine, even when you work in an SSH or dev container project.

#Troubleshooting

• Zed still uses an old key: a non-empty ACTUALYZE_API_KEY wins over the key on the LLM Providers page. Unset the variable and restart Zed.
• Settings error after editing available_models: a capabilities block is missing one of tools, images, parallel_tool_calls or prompt_cache_key, or an entry has no max_tokens.
• Function tools with reasoning_effort are not supported ... in /v1/chat/completions: set capabilities.chat_completions to false for that model.
• 402: a spend limit stopped the request before any model ran, so nothing was charged. The message says which limit: usually the key's budget, or the key's own monthly limit.
• 401: the key was rejected. It may be mistyped, revoked or expired, lack the inference scope, or belong to someone who is no longer on the key's team.
• 403: the request was refused. If the message says read-write permission is required, the key is read-only; create a read-write key. Otherwise your team can't use the model you asked for; check its access in the Model Catalog or pick another.
• 402 saying Budget required: the key's budget was deleted, archived or retired, or you no longer have access to it. Create a new key bound to a budget you can use.
• Model not found: name doesn't match a catalog model or Virtual Model your workspace serves.

#Reference

Requests you cancel mid-stream still draw down the usage they consumed.

For every provider option, see Zed's API access documentation.