Features

chat.dev runs persistent coding agents in isolated cloud machines and gives you several ways to control, fund, and integrate them.

Agent runtimes#

Choose a runtime when creating an agent:

API keys are managed from Settings > LLM Providers. General environment credentials are managed from Settings > Global Variables and per-agent settings. Tokens are encrypted at rest and only injected into agent runtimes when needed.

The Global Variables page shows the actual value on demand and lets you change the label, environment-variable name, value, description, and enabled state. Multiline values such as provider login JSON retain their line breaks when revealed and can be edited directly. Changes apply to agents that receive account-wide variables when their runtime environment is next prepared.

Repositories#

Agents can start from an existing GitHub repository or create a fresh repo for a new project. Public repositories receive a compute and token discount, which makes public demos and open-source maintenance cheaper to run.

Useful repo workflows:

• Spawn an agent from a repo, ask it to install dependencies, run tests, and commit changes on a branch.
• Create a new repo from the agent creation flow and have the agent commit a working demo as it builds.
• Keep a long-lived agent attached to a repo so installed packages, generated files, and local context persist between tasks.

Access surfaces#

You can control agents from several places:

• Web terminal for live PTY access and scrollback.
• Chat view for message-based agent interaction and readable output history.
• Workspace editor for editing the agent's files in the browser alongside Simplify and an optional terminal.
• SMS for commands, task dispatch, account balance, and agent status.
• Voice by phone or browser mic for hands-free agent control.
• Channel API for Slack, Discord, Telegram, support tools, and custom chat surfaces.
• Group chats for shared agents that teams can load, instruct, and monitor together.

VS Code and Cursor plugin#

The chat.dev Remote Agents plugin connects the editor on your computer to a chat.dev agent. Continue carries over the local project and its Codex, Claude Code, or Cursor conversations. Each conversation becomes a session on the shared cloud machine, with its own harness, model, terminal, and history.

The local folder and cloud workspace then mirror each other per file. Local edits appear on the agent, and files changed by the agent or browser editor update locally. The complete expected project listing is recorded before file contents begin transferring, while large files continue in the background and completed files remain usable.

You can also choose Open to browse your chat.dev agents and open one as a VS Code or Cursor project. The plugin is public on GitHub, and the installable VSIX is available from the latest release.

Browser workspace editor#

Open an agent's Files panel and select a text file to enter Workspace mode. The file tree stays on the left, open files appear as tabs in the center, Simplify stays on the right, and the terminal can be opened in a resizable bottom panel. The narrow icon rail keeps the dashboard, agent overview, agent settings, and global variables one click away without taking over the editing surface.

A single click opens a file for editing; a double click downloads it. Text changes save automatically to the agent machine. Updates from the coding agent, terminal, another browser editor, VS Code, or Cursor refresh the same open file, so all connected editors reflect the workspace on the agent. On a phone, Files, Editor, Simplify, and Terminal become four direct panel choices instead of squeezing every pane onto one screen.

Toolpacks inside agents#

Agents get platform capabilities through Toolpacks. Toolpacks are MCP-backed capability sets that can be attached when an agent is created or changed later from the agent settings page. The catalog is loaded from chat.dev at runtime, so agents should inspect the MCP server and its tool descriptions instead of relying on hardcoded API details.

Default chat.dev tools publish argument choices in their MCP schemas and generated markdown. For example, create_agent exposes repoMode with existing_repo, no_repo, and create_new_repo; when create_new_repo is selected, the agent creation call creates and attaches the GitHub repository in the same request.

Agent creation also exposes location explicitly. In the browser, opening New Agent from inside a team preselects that team and the form still lets you choose top level or another team. In MCP, create_agent accepts agentLocation with top_level or team; team placement can be supplied by ID or name.

Built-in chat.dev toolpacks are split by scope:

• Agent Introspection is attached by default. It lets a running agent inspect and manage its own work, including ports, domains, account funds, notifications, scheduled follow-ups, credentials, invites, and files sent to the user.
• System Admin is opt-in. It exposes broader account and environment controls such as listing agents, reading output, creating, starting, stopping, deleting, renaming, moving, or messaging agents, and changing environment configuration.
• Direct Speak is opt-in for Voice and YOLO router agents. It enables direct live conversation routing to a named agent.

Connected integrations such as GitHub, Google, OAuth apps, and GBrain machines appear in the same Toolpacks list when they are available. Integration toolpacks expose chat.dev platform-side access to the connected account or running machine; they are separate from command-line tools an agent can install inside its own workspace.

Common tool uses include:

• Exposing a local service and returning the public URL.
• Notifying the user by text or email.
• Sending local files, URL files, local images, URL images, or generated image assets to the user.
• Scheduling a future tool call, or scheduling a recurring tool pipeline that reads agent output, hands it to another agent for analysis, reads the result, and notifies the user.
• Creating, configuring, moving, instructing, or reading other same-account agents and teams.

Agent output and input-needed states#

The chat view, SMS, and voice surfaces receive structured progress from coding agents. Routine command output is kept out of the simplified transcript when it would be raw terminal noise, but meaningful agent messages and task progress are recorded in history.

When Codex or Claude is blocked on an interactive terminal choice, chat.dev emits an explicit waiting_for_user_choice progress state. Simplify renders it as an input-needed message, SMS sends the same prompt with the agent prefix, and voice speaks the clean prompt so the user can answer without opening the terminal.

Machines and previews#

Machine tiers range from small standard VMs to an A100 80GB GPU tier. Every coding agent has persistent storage, so stopping a machine pauses compute but keeps files. ChatGPT+Tools agents run inside chat.dev without a visible worker VM.

For web apps, dashboards, APIs, and demos, expose the service port from the agent settings or with the expose_port tool. chat.dev proxies the port through the live worker connection and gives the service an HTTPS URL; you can attach a custom domain when you need a stable review link.

Funding and budgets#

Accounts can deposit SOL, fund individual agent wallets, and set spending limits. Agents can either bill the account balance or pay runtime costs from their own wallet. SOL deposits can also be used to top up token spend when free AI credits run out. This supports normal coding work, wallet-aware apps, and self-funded experiments.

Subscription tiers include monthly OpenAI credits and compute hours. Expert unlocks the GPU tier and applies a discount to non-standard machine tiers.