Building with other coding agents

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. Those patterns apply to every agent.

Work through the 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:

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:

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

// 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:

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

   // 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 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:

[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:

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

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

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

For more failure modes, see Troubleshooting.

Next steps

• Building with Claude Code: the build workflow and prompting patterns, which apply to every agent.
• Project structure: what helix init creates and what each file is for.
• CLI reference: every shipped helix command.