Cursor shut out Russian users. Building your own Cursor on Zed in one evening

September 2026. Cursor users in Russia started getting locked out en masse: accounts blocked, subscriptions not renewed, key-based access cut off. An old story — other services shut their doors the same way. The good news: in 2026 you no longer need to be tied to a specific editor. In one evening we put together a replacement that reproduces everything people love about Cursor — an AI chat on the right, inline edits right in the code, git and error highlighting in the file tree, MCP servers — and it runs on your own keys, the ones nobody can take away.

Why Zed

• An open-source editor written in Rust — fast, with native support for AI agents over the ACP protocol. AI isn't bolted on top like in VS Code; the editor is designed around it.
• The UI is drawn by your GPU, not your CPU. Zed is fully hardware-accelerated: rendering happens on the GPU. That's where the signature instant feel comes from — the interface doesn't freeze while a language server chews through a large project. A huge TypeScript monolith opens and works without the long "indexing" hangs that VS Code-style editors are known for.
• Any model you like. Chinese coding plans (GLM from Z.AI, Qwen from Alibaba, Kimi from Moonshot) are officially available in Russia and cost a flat subscription fee instead of burning tokens by the hour.
• Everything belongs to you: your keys, your JSON settings, your MCP servers. Nobody flips the switch.

Step 1. The editor

Download Zed from zed.dev — there are ready-made builds for macOS (it flies on Apple Silicon) and Linux. Installs in one click.

The second pleasant surprise is that language support is already built in. TypeScript, JavaScript, CSS, Tailwind CSS, JSON, Python, Go, Rust, Bash, C/C++, YAML and Markdown work out of the box, plus native ESLint integration for JS/TS. Zed downloads the language servers automatically when you first open a project — there's nothing to look for or install.

Compare that with Cursor: it's the same VS Code fork, and the whole frontend stack there is assembled by hand from extensions — TypeScript, ESLint, Tailwind Intellisense, Prettier and so on. Every extension is a separate point of failure and an extra setup step. In Zed this stage simply doesn't exist: unpack, open the project, work. A fast IDE setup is an underrated thing when you're setting up not one computer but a whole workflow.

Step 2. Inline assist: a model for edits right in the code

This is the equivalent of Cursor's Cmd+K: select some code, press Cmd+I (works out of the box), describe the task — and the model edits the code. For it, you plug a native provider into ~/.config/zed/settings.json:

{
  "language_models": {
    "openai_compatible": {
      "Z.AI": {
        "api_url": "https://api.z.ai/api/coding/paas/v4",
        "available_models": [
          {
            "name": "glm-5.3-flash",
            "max_tokens": 200000,
            "max_output_tokens": 32000,
            "reasoning_effort": "medium",
            "capabilities": {
              "tools": true,
              "parallel_tool_calls": true,
              "chat_completions": true,
              "interleaved_reasoning": true
            }
          }
        ]
      }
    }
  }
}

The key does not go here — settings.json doesn't store it. Paste it via the UI: agent panel → Settings → Language Models → Z.AI → the key lands in the system Keychain.

Then explicitly assign a model to the inline assist — this is a common misconfiguration: without it you get "LLM provider is not configured", because inline edits use the default model, not the one selected in the chat:

{
  "agent": {
    "inline_assistant_model": { "provider": "Z.AI", "model": "glm-5.3-flash" },
    "inline_assistant_use_streaming_tools": true,
    "auto_compact": { "threshold": "80%" }
  }
}

auto_compact here is the context auto-compaction threshold for long threads: 80% means that once the model's context window is 80% full, older messages get folded into a summary and the conversation continues without a hard stop.

Step 3. The agent panel: GLM, Qwen Code, Kimi Code — whoever you like

The second, main part is the agent with tools (files, terminal, MCP) that lives in the right-hand panel. Zed installs external agents from its built-in registry in one click: Agent Settings → External Agents → Install from Registry.

You can install several agents and switch between them. We use three:

• glm-acp-agent (Z.AI / GLM);
• Qwen Code (Alibaba / Qwen);
• Kimi (Moonshot / Kimi).

Each one gets its own block in agent_servers:

{
  "agent_servers": {
    "glm-acp-agent": {
      "type": "registry",
      "default_config_options": {
        "model": "glm-5.3-flash",
        "mode": "bypass_permissions",
        "thought_level": "high"
      },
      "env": {
        "Z_AI_API_KEY": "YOUR_KEY_FROM_THE_Z.AI_CONSOLE"
      }
    },
    "qwen-code": {
      "type": "registry",
      "default_config_options": {
        "model": "your-route-from-qwen-settings"
      }
    },
    "kimi": {
      "type": "registry",
      "default_mode": "default"
    }
  }
}

The differences are minimal: the GLM agent gets its key through env (taken from the z.ai console), while Qwen Code and Kimi will offer to sign in on first launch — they store their keys themselves. default_config_options pins the model, the permission mode and the "thought level" so every new thread starts with your parameters instead of defaults.

bypass_permissions for the GLM agent means "don't ask for permission on every action" — like YOLO mode in other editors. Convenient, but enable it deliberately: the agent will be able to change files and run commands without confirmations.

To be fair: Cursor does have a choice of agents too — its built-in modes, included with the subscription — and its autocomplete and inline edits are excellent. But there are two caveats. First, on the free tier autocomplete and inline edits are tightly limited, and full agents are essentially a paid-subscription feature. Second — and September made this vivid — the subscription belongs to the service and can be cut off at any moment and for any reason: geography today, changed terms tomorrow. Your entire workflow stops at once. In our setup the editor, the agents and the keys are yours: the only thing that can burn is one provider's key, and replacing it takes five minutes — not your whole working environment.

Step 4. A Cursor-style layout

Files on the left, code in the center, agent on the right — it takes two lines:

{
  "project_panel": { "dock": "left" },
  "agent": { "sidebar_side": "right" }
}

The editor in the center is the default behavior. The panels toggle with Cmd+B and Cmd+;, and Zed remembers their state between sessions.

Step 5. Cursor-style shortcuts

Cursor is a VS Code fork, so the base is already there: set "base_keymap": "VSCode" in the settings and the everyday shortcuts (Cmd+P, Cmd+Shift+P, Cmd+B) match on their own.

The inline assist is Cmd+I out of the box, the agent panel is Cmd+?. And Cursor's signature habit of throwing selected code at the agent comes back with one block in ~/.config/zed/keymap.json:

[
  {
    "context": "Editor && mode == full",
    "bindings": {
      "cmd-l": "agent::AddSelectionToThread"
    }
  },
  {
    "context": "Editor && mode == full",
    "unbind": {
      "cmd->": "agent::AddSelectionToThread"
    }
  }
]

Now you select a function, hit Cmd+L, and it flies into the agent thread as context. (A block for the AcpThread context repeats the same binding so the shortcut also works when focus is already in the agent panel.)

Step 6. Highlighting changes and errors in the file tree

That familiar Cursor look: modified files in color, files with errors in red with a count:

{
  "project_panel": {
    "git_status": true,
    "git_status_indicator": true,
    "show_diagnostics": "all",
    "diagnostic_badges": true
  }
}

One nuance: diagnostics (including ESLint) come from the LSP, so files are highlighted once they've been opened. Running the linter across the whole project without opening it is not a Zed feature.

Step 7. MCP servers

Your MCP servers from Cursor move into the same settings.json, into the context_servers section. A piece of practical advice: don't drag keys and PATH into settings.json — wrap each server in a shell script and keep a single line in the config:

{
  "context_servers": {
    "my-mcp-server": {
      "enabled": true,
      "command": "~/mcp/bin/my-mcp-server.sh",
      "args": []
    }
  }
}

The wrapper is a regular bash script: it pulls the token from the Keychain, sets the environment variables, starts the server. The benefits:

• no secrets in settings.json — you can show it, commit it, or share it with a colleague without a second thought;
• nvm-node paths live inside the script — a node upgrade breaks one script, not six config entries;
• enabling/disabling a server is the enabled flag, no need to delete settings.

The pitfalls we hit (save yourself an evening)

• "LLM provider is not configured" on inline edits — the fix is not the key but assigning agent.inline_assistant_model (see step 2) or picking a default model in the panel's model selector.
• An nvm update broke every node-based server at once — paths like ~/.nvm/versions/node/v26.3.0/... died after the upgrade. Wrapper scripts solve this once and for all.
• An unavailable MCP server can prevent the agent thread from being created. Zed has no automatic "skip a failed server" (a known issue). Prevention: keep unused servers disabled ("enabled": false) and enable them when needed. If a server dies mid-session — not critical, the chat keeps working.
• "Incomplete model stream: no supported terminal reason" — the response stream was cut off (network/proxy on the way to the API). Not a breakage: regenerate the answer.

The bottom line

Our setup isn't perfect: Cursor still has the best-polished autocomplete and the zero-config out-of-the-box experience. But the price of that convenience is total dependence on someone else's subscription. If you want independence, Zed delivers the same key scenarios in one evening of configuration.

TL;DR

Cursor shut its doors to Russia, but that's not the end: Zed plus the GLM/Qwen/Kimi coding plans give you the same scenarios — a chat agent, inline edits on Cmd+I, git and errors in the file tree, MCP servers — on your own keys, with no risk of a subscription being cut off. Setup takes one evening; all the configs are in the article.