Development Tools

Helix ships with 12 built-in MCP servers that expose roughly 70 tools to your agents. These tools cover code intelligence, file management, terminal access, web interaction, remote operations, and more. Every tool runs through the Model Context Protocol so the agent can discover, call, and compose them in a uniform way.

This page explains what each tool group does, how tools are distributed across agent layers, and how to extend the toolkit with your own MCP servers.

---

How Tools Connect to Agents

All tools in Helix are exposed as MCP servers. When a session starts, the system assembles the tool set based on the workspace configuration and the agent layer:

• Manager Agent — Only sees the Longterm Agent tool. Its job is to coordinate, not to execute.
• Execution Agent — Has access to all tools except Longterm Agent. This is where real work happens.
• Sub Agents — Inherit the parent session's tools, minus the SubAgent server itself (to prevent recursive spawning).

This layered filtering keeps each agent focused on its role while preventing unintended tool loops.

---

Code Intelligence — Serena LSP

28 tools · Global shared service

Serena is the code intelligence engine at the heart of Helix. It connects to Language Server Protocol servers for Go, TypeScript, Python, Rust, Dart, Java, and C/C++, giving agents the same deep understanding of code that a human gets from an IDE.

Symbol Analysis

Tool	What it does
activate_project	Open a project and start its language server
list_projects	Show all active projects and their LSP status
get_symbols_overview	List all classes, functions, and variables in a file
find_symbol	Search for symbols by name across a project
go_to_definition	Jump to where a symbol is defined
find_references	Find every place a symbol is used
get_hover_info	Get type information and documentation for a symbol
rename_symbol	Rename a symbol across the entire project safely

File Operations

Tool	What it does
read-file	Read file contents with optional line range
write_file	Create or overwrite a file
list_dir	List directory contents, optionally recursive
find_file	Find files matching a wildcard pattern
search_pattern	Search for regex patterns across files
replace_content	Replace text using literal match or regex
delete_lines	Remove specific lines from a file
replace_lines	Replace specific lines with new content
insert_at_line	Insert content at a specific line number

Symbol Editing

Tool	What it does
replace_symbol_body	Replace an entire function or class definition
insert_after_symbol	Insert code immediately after a symbol
insert_before_symbol	Insert code immediately before a symbol

Workflow Guidance

Tool	What it does
think_about_collected_information	Reflect on whether gathered information is sufficient
think_about_task_adherence	Check whether the agent is still on track
think_about_whether_you_are_done	Verify that the task is truly complete
summarize_changes	Produce a summary of all code modifications
start_code_review	Launch an automated code review cycle
switch_modes	Switch between editing, planning, and interactive modes
prepare_for_new_conversation	Reset context for a fresh session
initial_instructions	Load the Serena instruction manual

The workflow tools are what make Serena more than a code search engine. They guide the agent through a disciplined process: gather information, confirm direction, make changes, review results, and summarize. This structure is what lets Helix handle 50-step tasks without losing coherence.

tip

Serena auto-detects project languages from marker files like go.mod, tsconfig.json, pyproject.toml, and Cargo.toml. No manual configuration is needed in most cases.

---

Shell and Terminal

Shell Execution

1 tool · Global shared service

Tool	What it does
execute_shell	Run a shell command and return its output

Straightforward command execution with configurable timeout and working directory. This is how agents run builds, tests, linters, package managers, and any other CLI tool.

Tmux Terminal

6 tools · Workspace-level service

Tool	What it does
create_window	Create a new terminal window
close_window	Close a terminal window
execute_command	Run a command in a specific window
read_output	Read the current output of a window
send_keys	Send keystrokes to a window
kill_process	Terminate the running process in a window

Tmux gives agents persistent terminal sessions. Unlike execute_shell which runs one command and returns, Tmux windows stay open. This is essential for:

• Long-running processes like dev servers, watch modes, or database processes
• Interactive debugging where the agent needs to send input and read output over multiple steps
• Parallel terminal work where different windows handle different concerns

In the UI, each Tmux window shows as a separate terminal tab. You can watch the agent's terminal work in real time.

---

Web and Browser

Web Scraping — Snag

4 tools · Global shared service

Tool	What it does
fetch_url	Fetch a URL with optional JavaScript rendering
fetch_tab	Capture content from an already-open browser tab
list_tabs	List all open browser tabs
screenshot_url	Take a screenshot of a web page

Snag handles web content retrieval. It can fetch static pages, render JavaScript-heavy sites through a real browser, and capture content from tabs you already have open (useful for pulling documentation or issue details from authenticated sessions).

Chrome DevTools

~10 tools · External Stdio service

Tool	What it does
navigate_page	Navigate to a URL
new_page	Open a new browser page
click	Click on a page element
fill	Fill in a form field
take_screenshot	Capture a screenshot
take_snapshot	Capture a DOM snapshot
evaluate_script	Run JavaScript in the page context
list_network_requests	List captured network requests
performance_start_trace	Start a performance trace
performance_stop_trace	Stop and retrieve a performance trace

Chrome DevTools gives agents full browser automation. This is powerful for testing web UIs, debugging frontend issues, filling out forms, and verifying visual output. The agent can navigate pages, interact with elements, run scripts, and capture screenshots — the same capabilities you would use in manual browser testing.

---

Remote Operations — SSH

6 tools · Global shared service

Tool	What it does
remote_connect	Register an SSH connection with key or password auth
remote_disconnect	Close and remove a connection
remote_list	List all registered connections and their status
remote_shell	Execute a shell command on a remote server
remote_upload	Upload a local file or directory to a remote server via SFTP
remote_download	Download a remote file to local path via SFTP

Remote SSH lets agents work on remote servers without requiring you to run Helix on that machine. The agent can connect to staging environments, production servers, or cloud instances, then run commands and transfer files. Connections are registered by name and reused across the session.

Typical use cases:

• Deploy and verify changes on a staging server
• Pull logs or configuration from a remote environment
• Upload build artifacts or configuration files
• Debug issues that only reproduce on a specific server

---

Agent Collaboration

Sub Agent

2 tools · Workspace-level service

Tool	What it does
run_subagent	Launch an independent sub agent to execute a task concurrently
create_worktree_binding	Create a Git worktree binding for isolated code changes

Sub agents are how Helix runs parallel work. The execution agent can spawn multiple sub agents in a single message, and they all run concurrently with independent contexts. Each sub agent inherits the parent's tools (minus the SubAgent server itself) and returns a result summary when done.

create_worktree_binding pairs with sub agents for code modification tasks. It creates an isolated Git worktree so the sub agent can make changes on a separate branch without interfering with the main working tree or other sub agents. After the task completes, changes are merged back automatically.

Longterm Agent

4 tools · Global shared service (Manager layer only)

Tool	What it does
longterm_chat	Send a conversation turn to the execution agent or create a new session
longterm_history	Retrieve conversation history with configurable detail level
longterm_history_item	Get a specific history item by ID
longterm_check_id	Check whether a session ID is still valid

The Longterm Agent is the bridge between the Manager and Execution layers. The Manager uses it to delegate work, check progress, and retrieve results. This separation is what lets the Manager maintain a high-level view of the task while the Execution Agent handles the details.

---

Context and Cache

1 tool · Workspace-level service

Tool	What it does
recall_cached_content	Retrieve cached tool call results by SHA256 hash

When tool outputs are large (long file contents, big search results, verbose command output), Helix caches them and injects a compact reference into the conversation. The [CACHED] marker in conversation messages includes a hash that the agent can use to recall the full content when needed.

This mechanism is a key part of how Helix keeps long sessions viable. Instead of flooding the context window with repeated large outputs, the system stores them once and lets the agent pull them back on demand. Combined with conversation compaction, this lets sessions run for hours without context collapse.

---

Port Forwarding

3 tools · Workspace-level service (container environments only)

Tool	What it does
expose_port	Expose a container port with HTTP reverse proxy or TCP tunnel
list_ports	List all active port forwarding rules
close_port	Close a port forwarding rule

Port forwarding is available when Helix runs inside a container environment. It lets agents expose services running inside the container (like dev servers, databases, or API endpoints) so they can be accessed from outside. This is essential for testing web applications or APIs during container-based development.

---

Adding Custom MCP Servers

Beyond the 12 built-in servers, you can add any MCP-compatible server to extend Helix's capabilities. Custom servers are managed through the settings UI and support two transport modes.

HTTP (StreamableHTTP)

For MCP servers running as HTTP services:

{
  "name": "my-database-tools",
  "url": "http://localhost:3001/mcp",
  "enabled": true
}

Stdio

For MCP servers that run as local processes:

{
  "name": "my-custom-tools",
  "command": "npx",
  "args": ["-y", "my-mcp-server@latest"],
  "env": {
    "API_KEY": "your-key"
  },
  "enabled": true
}

Custom server configurations are stored in global_mcp_servers.json and are available across all workspaces. New sessions automatically include globally enabled servers. You can also manage which servers are active on a per-session basis.

Popular extension possibilities:

• Database tools — Query and manage databases directly from agent conversations
• Cloud provider tools — Interact with AWS, GCP, or Azure resources
• Issue tracker tools — Create and manage issues in Jira, Linear, or GitHub Issues
• Monitoring tools — Pull metrics and alerts from Datadog, Grafana, or similar platforms
• Custom internal tools — Expose your team's internal APIs and workflows to the agent

tip

The MCP ecosystem is growing rapidly. Check the MCP servers directory for community-maintained servers you can add to Helix.

---

Tool Access by Agent Layer

Not all tools are available to every agent. Here is the complete access matrix:

Tool Server	Manager	Execution Agent	Sub Agent
Longterm Agent	✅	—	—
Serena LSP	—	✅	✅
Shell	—	✅	✅
Tmux Terminal	—	✅	✅
Snag (Web)	—	✅	✅
Chrome DevTools	—	✅	✅
Remote SSH	—	✅	✅
Skills	—	✅	✅
Context Cache	—	✅	✅
Port Forward	—	✅	✅
SubAgent	—	✅	—
Custom MCP Servers	—	✅	✅

Key rules:

• Manager only has longterm_chat and related tools. It delegates everything through the Execution Agent.
• Execution Agent has the full tool set (everything except Longterm Agent).
• Sub Agents inherit the Execution Agent's tools but cannot spawn further sub agents or create worktree bindings (prevents recursive loops).
• Custom MCP servers follow the same pattern as built-in workspace tools.

---

What Comes Next

• Workflows and Extension — Git worktree workflow, Skills system, Agent Profiles, and how to build on top of Helix's tool foundation
• Serena LSP Setup — Detailed guide for configuring Serena's language server integration
• Multi-Agent Architecture — How Manager, Execution, and Sub Agents coordinate work