# Building with other coding agents

> Point Cursor, VS Code (Copilot), Codex, or any MCP-capable coding agent at a Helix project by configuring the local Helix MCP server.

Helix isn't tied to Claude Code. Any MCP-capable coding agent can build a Helix project, because the agent works through two standard, cross-platform pieces: the local `helix mcp` server (stdio) and the Helix CLI it runs in a terminal. This page shows how to point Cursor, VS Code (GitHub Copilot), Codex, or another MCP client at your project.

For the build workflow itself, the prompting patterns, and what stays in your hands, see [Building with Claude Code](/documentation/getting-started/building-with-claude/). Those patterns apply to every agent.

Work through the [Quickstart](/documentation/getting-started/quickstart/) first. Everything up to and including `helix init` is the same; this page only replaces the "build with Claude" step.

## Two things are true for every tool

Set these once, then configure your specific tool below.

- **You log in with the CLI, once per machine.** `helix login` saves your session to `~/.tray.config` (`%USERPROFILE%\.tray.config` on Windows) machine-wide, so every editor and agent on that machine inherits it. There's no per-tool login.
- **You run the CLI for the rest.** Deploying, selecting a workspace, and connecting authentications are CLI actions. A capable agent runs `helix dev` and `helix deploy` for you through its terminal, but `helix login`, `helix workspace select`, and `helix auth connect` are yours to run in a plain terminal.

What changes per tool is only **where the MCP server is configured**. The server definition is the same underneath, and matches the `.mcp.json` that `helix init` writes:

| Field | Value |
|---|---|
| Command | `npx` |
| Arguments | `helix mcp` |
| Working directory | your Helix project root |
| Transport | stdio |

:::note{title="Windows note"}
Spawning `npx` from an MCP client on native Windows can fail with `spawn npx ENOENT`. If a server won't start on Windows, wrap the command with `cmd /c`: command `cmd`, arguments `/c npx helix mcp`. Each example below shows the macOS and Linux form first, then the Windows-safe form. On WSL, use the macOS and Linux form.
:::

## Cursor

`helix init` already generates `.cursor/mcp.json`, so there's often nothing to write.

1. Open the project folder in Cursor.
2. Cursor detects `.cursor/mcp.json` and prompts to enable the **helix** MCP server. Allow it. You can also check **Cursor Settings → MCP**; the `helix` server should be listed and toggled on.
3. Switch the chat sidebar to **Agent** mode.
4. Build as you would with Claude Code: describe outcomes, not tools ("add an endpoint that returns X, run it locally, and show me the response").

If the file is missing, `.cursor/mcp.json` should look like this:

```jsonc
// macOS / Linux (and WSL)
{
  "mcpServers": {
    "helix": {
      "command": "npx",
      "args": ["helix", "mcp"],
      "cwd": "."
    }
  }
}
```

```jsonc
// Native Windows, if the server won't start
{
  "mcpServers": {
    "helix": {
      "command": "cmd",
      "args": ["/c", "npx", "helix", "mcp"],
      "cwd": "."
    }
  }
}
```

## VS Code (GitHub Copilot agent mode)

Requires GitHub Copilot with agent mode enabled. VS Code uses a different filename and schema: the key is `servers` (not `mcpServers`), and each entry takes an explicit `type`.

1. In your project, create `.vscode/mcp.json`:

   ```jsonc
   // macOS / Linux (and WSL)
   {
     "servers": {
       "helix": {
         "type": "stdio",
         "command": "npx",
         "args": ["helix", "mcp"]
       }
     }
   }
   ```

   ```jsonc
   // Native Windows, if the server won't start
   {
     "servers": {
       "helix": {
         "type": "stdio",
         "command": "cmd",
         "args": ["/c", "npx", "helix", "mcp"]
       }
     }
   }
   ```

   You can also run **MCP: Add Server** from the Command Palette for a guided version of the same thing.

2. Open the **Chat** view and switch the mode dropdown to **Agent**.
3. Click the tools icon in the chat box and confirm the **helix** tools are enabled.
4. Build as usual. Copilot's agent runs `helix dev` and `helix deploy` through the integrated terminal when you ask it to.

If nothing appears, confirm MCP support is on (`"chat.mcp.enabled": true` in settings, on by default in current VS Code) and reload the window. VS Code's MCP support is recent and its config schema still changes between releases, so check the [VS Code MCP docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) if the config above doesn't work.

## Codex and other MCP clients

OpenAI's Codex CLI, and most terminal agents, keep MCP servers in a config file rather than per project. For Codex, that's `~/.codex/config.toml` (a project-scoped `.codex/config.toml` also works). Add:

```toml
[mcp_servers.helix]
command = "npx"
args = ["helix", "mcp"]
# cwd = "/absolute/path/to/your/helix-project"   # if you run codex from elsewhere
```

On native Windows, if that fails to start, use the wrapper form:

```toml
[mcp_servers.helix]
command = "cmd"
args = ["/c", "npx", "helix", "mcp"]
```

Codex also has a helper that writes the same entry for you:

```bash
codex mcp add helix -- npx helix mcp
```

Then run `codex` from inside your Helix project directory and build normally.

**Any other stdio MCP client** (Cline, Windsurf, Zed, Gemini CLI, and so on) follows the same recipe: register a server named `helix` with command `npx`, argument `helix mcp`, transport stdio, and the working directory set to your project root. Consult that tool's "add an MCP server" docs for where its config lives; the server definition is the table at the top of this page.

## No agent at all

You don't need an AI tool. A Helix project is TypeScript in a normal repo, so you can open it in any editor, write `functions/` and `app/` code by hand, and use the CLI directly: `helix dev` to run and `helix deploy` to ship. The MCP server exists to give an agent structured access to the project; it's optional if you're writing the code yourself.

## Troubleshooting

| Symptom | Fix |
|---|---|
| MCP server won't start on Windows (`spawn npx ENOENT`, or helix tools missing) | Wrap the command with `cmd /c` in the client's MCP config, as shown in the Windows forms above. |
| Agent can't see the Helix tools | Confirm the config file is in the right place for that tool (`.cursor/mcp.json`, `.vscode/mcp.json`, `~/.codex/config.toml`), the server is toggled on, and you've reloaded the editor. |
| Agent runs tools but can't deploy, or reports "not logged in" | Run `helix login` and `helix workspace select` in a plain terminal on that machine. Login is machine-wide via `~/.tray.config`, and the agent inherits it. |
| Old CLI installed | `npm uninstall -g @trayio/helix-cli` (the retired scope), then `npm install -g @trayai/helix-cli`. |

For more failure modes, see [Troubleshooting](/documentation/troubleshooting/).

## Next steps

- [Building with Claude Code](/documentation/getting-started/building-with-claude/): the build workflow and prompting patterns, which apply to every agent.
- [Project structure](/documentation/getting-started/project-structure/): what `helix init` creates and what each file is for.
- [CLI reference](/documentation/reference/cli/): every shipped `helix` command.

---

Canonical: https://helix.tray.ai/documentation/getting-started/building-with-other-agents/
Any link on this page is available as markdown by appending .md to its URL.
Full corpus: https://helix.tray.ai/documentation/llms-full.txt