---
title: "Zed with EU-hosted open models · Agent setup guide"
description: "Add inference.eu as an OpenAI-compatible provider in the Zed editor and run its Agent Panel on open-weight models processed in EU data centres."
canonical: "https://inference.eu/integrations/zed/"
language: "en"
---

IDEs and editors · Zed

# Use Zed with open-source models hosted in the EU

Zed is a fast, open-source code editor with a built-in agent. It supports OpenAI-compatible providers in settings.json, so you can run its Agent Panel and inline assistant on open-weight models at inference.eu, processed in European data centres and sent directly from your editor.

[Contact sales](https://inference.eu/contact/)[Setup](#setup)

1.  01API format: OpenAI
2.  02EU data centres
3.  03Covered by one DPA

## Set it up in a few minutes

1.  1

    Create an API key in your inference.eu account and export it as `INFERENCE_EU_API_KEY`, or plan to paste it in Zed's settings.

2.  2

    Run `agent: open settings`, go to LLM Providers and click Add Provider, or edit `settings.json` directly.

3.  3

    Add an `openai_compatible` provider named `inference-eu` with `api_url` set to the inference.eu base URL and the models you want.

4.  4

    Enter the API key in the provider settings, or let Zed read `INFERENCE_EU_API_KEY` from the environment.

5.  5

    Open the Agent Panel, choose an inference.eu model and ask it to make a small change.

~/.config/zed/settings.json

```
{
  "language_models": {
    "openai_compatible": {
      // Zed reads the key from INFERENCE_EU_API_KEY for this provider id.
      "inference-eu": {
        "api_url": "https://api.inference.eu/v1",
        "available_models": [
          {
            "name": "qwen3-coder-480b-a35b-instruct",
            "display_name": "Qwen3 Coder 480B (EU)",
            "max_tokens": 262144,
            "capabilities": { "tools": true, "images": false }
          },
          {
            "name": "gpt-oss-120b",
            "display_name": "gpt-oss-120b (EU)",
            "max_tokens": 131072,
            "capabilities": { "tools": true, "images": false }
          }
        ]
      }
    }
  }
}
```

## What Zed is

Zed is a code editor written in Rust and built by Zed Industries, focused on speed and real-time collaboration. It includes an Agent Panel that can read your project, edit files and run commands, an inline assistant for targeted edits, and edit predictions while you type. It also hosts external agents through the Agent Client Protocol.

For its own AI features, Zed lets you bring your own provider. Besides first-class providers it supports any OpenAI-compatible endpoint, which is how you connect inference.eu without a plugin.

## How the configuration works

OpenAI-compatible providers live under `language_models.openai_compatible` in `settings.json`. Each provider has a name, an `api_url` and a list of `available_models`. For each model, set `name` to the exact inference.eu id and `max_tokens` to its context window, and declare `capabilities` such as `tools`.

Zed does not store keys in `settings.json`. Enter the key in the provider settings, where it goes to the system keychain, or set an environment variable. Zed builds the variable name from the provider id in upper snake case plus `_API_KEY`, so the provider `inference-eu` reads `INFERENCE_EU_API_KEY`. A non-empty environment variable takes precedence over the keychain.

## Which models to choose

The Agent Panel makes repeated tool calls to read files, edit code and run commands, so pick models with dependable tool calling. `qwen3-coder-480b-a35b-instruct` is a strong default for agent work. `glm-5.3` and `kimi-k3` are good for planning larger changes and explaining unfamiliar code; add them as further entries with their context sizes.

For the inline assistant and quick questions, `gpt-oss-120b` is fast. If a model supports reasoning effort, you can set `reasoning_effort` on its entry. Edit predictions are a separate feature with their own provider setting and are not served by these chat models.

## Troubleshooting

If the provider shows as not authenticated, Zed found no key. Enter it in the provider settings, or start Zed from a shell where `INFERENCE_EU_API_KEY` is set, keeping in mind that the name follows the provider id. A 401 means the key is wrong. If you set the variable and later want to use the keychain instead, unset it and restart Zed.

"Model not found" means `name` differs from the inference.eu id. If the agent replies without calling tools, check that `capabilities.tools` is `true` and use a model trained for tool use. If the endpoint rejects the output limit, set `capabilities.max_tokens_parameter` to `true`.

## Keeping code and data in the EU

Zed initialises language model providers in the local app and sends requests from your machine to the `api_url` you set, also for SSH and remote projects. With inference.eu, the code and context in your requests are processed in EU data centres and never used for training. We sign a data processing agreement under Article 28 GDPR, share our subprocessor list and bill in euros.

Other Zed features have their own settings. Edit predictions can use Zed's hosted service, and Zed collects telemetry that you can turn off. Review both if your policy requires all code to stay with inference.eu.

## Zed

Category

IDEs and editors

Maker

Zed Industries

API format

OpenAI

Processing

EU data centres

Website

[zed.dev](https://zed.dev/)

Documentation

[zed.dev](https://zed.dev/docs/ai/use-api-access)

## Zed: common questions

The questions buyers, developers and legal teams ask us most. Something missing? Ask us directly.

Yes. Zed lets you bring your own provider for its AI features. With inference.eu configured as an OpenAI-compatible provider, the Agent Panel and inline assistant use your inference.eu key, and model usage is billed by inference.eu in euros.

In the system keychain when you enter it in the provider settings, or in an environment variable. Zed does not read keys from settings.json. For the provider id \`inference-eu\`, the variable is \`INFERENCE\_EU\_API\_KEY\`.

Qwen3 Coder 480B is a strong default because it handles tool calls reliably. GLM-5.3 and Kimi K3 suit planning and code explanations, and gpt-oss-120b is quick for inline edits. Add several models and switch in the model picker.

Agent and inline assistant requests go from your machine to the provider you configure. Edit predictions are configured separately and may use Zed's hosted service, and Zed collects telemetry you can disable. Check both settings for a strict setup.

Yes. Set \`max\_tokens\` for each model to its context window. Zed uses it to decide how much of your conversation and files fit into a request. Use the value listed for the model on inference.eu.

The model is not returning tool calls. Make sure \`capabilities.tools\` is \`true\` for the model and pick one trained for tool use, such as Qwen3 Coder, GLM-5.3 or Kimi K3.

Yes. Zed initialises providers in the local app, so the key and endpoint come from your local keychain or environment, and requests go from your machine to inference.eu even when the project runs on a remote server.

Edit predictions are a separate feature with their own provider choice and need models trained for that task. The chat models on this page are meant for the Agent Panel and inline assistant. Turn edit predictions off if they would send code to a service you have not approved.

Some endpoints expect the output limit as \`max\_tokens\` rather than \`max\_completion\_tokens\`. Setting \`capabilities.max\_tokens\_parameter\` to \`true\` makes Zed send \`max\_tokens\`. Use it only if requests are rejected because of the output limit field.

Yes. Share the \`language\_models\` block from settings.json, which contains no secrets. Each developer adds their own key through the provider settings or the \`INFERENCE\_EU\_API\_KEY\` variable, so usage is tracked per person.

[Ask a question](https://inference.eu/contact/)

## Related

[All integrations](https://inference.eu/integrations/)

-   [ContinueConfigure the Continue extension for VS Code and JetBrains to use open-weight models processed in EU data centres, role by role, in config.yaml.IDEs and editors](https://inference.eu/integrations/continue/)
-   [ClineConnect the Cline coding agent for VS Code and the terminal to open-weight models processed in EU data centres with the OpenAI Compatible provider.Coding agents](https://inference.eu/integrations/cline/)
-   [JetBrains AI AssistantConnect JetBrains AI Assistant to open-weight models processed in EU data centres through its OpenAI-compatible provider, and assign them to IDE features.IDEs and editors](https://inference.eu/integrations/jetbrains-ai-assistant/)
-   [CursorUse open-weight models processed in EU data centres for Cursor Chat and Agent through the OpenAI base URL override. What it covers and what still goes via Cursor.IDEs and editors](https://inference.eu/integrations/cursor/)

## Move your AI workloads to EU infrastructure

Tell us which models you use and roughly how much traffic you have. We reply within one working day with pricing and next steps.

-   Reply within one working day
-   Pricing for your volume
-   DPA ready to sign