---
title: Agents
description: Glade runs the Claude Code, Codex, Cursor, Grok Build and OpenCode CLIs you already have, side by side. Connect them, compare them and switch between them mid-task.
sidebar:
  label: Overview
  icon: dashboard-square-01
---

Glade doesn't host models or sell a plan. It runs the official agent CLIs on your machine, signed in
with your own accounts, and gives them one shared workspace. Usage counts against the plans you
already pay for.

**[Claude Code](/agents/claude-code)**

Anthropic. Needs 2.1.267 or newer.

**[Codex](/agents/codex)**

OpenAI. Needs 0.158.0 or newer.

**[Cursor](/agents/cursor)**

Cursor's CLI. Needs 2026.1.0 or newer.

**[Grok Build](/agents/grok-build)**

xAI. Needs 1.0.0 or newer.

**[OpenCode](/agents/opencode)**

Open source, with free models. Needs 2.0.0 or newer.

## Connect an agent

1. **Install the CLI**

    Follow the agent's own install guide, linked from its page, then check that it runs in a fresh
    terminal.

2. **Sign in**

    Sign in the way the agent asks you to. For Claude Code and Codex, **Sign in** in **Settings →
    Providers** runs the CLI's own sign-in inside Glade. Credentials stay with the CLI.

3. **Check it in Glade**

    **Settings → Providers** shows whether each agent was found, its version and its sign-in. An
    older version shows **Update required**. If a CLI lives somewhere unusual, set its path there.

4. **Pick a model**

    Models and effort levels come from the agent itself, so the picker reflects its version, your
    account and its configuration. Star a model to keep it one click away.

## What works where

Every agent gets the essentials: chats, tool activity, approvals, terminals, diffs, Git,
[worktrees](/features/worktrees), [skills](/features/skills), [MCP servers](/features/mcp-servers),
the [browser](/features/browser) and [Computer Use](/features/computer-use). A few controls depend on
the agent:

| Feature                      | Claude Code | Codex  | Cursor | Grok Build | OpenCode |
| ---------------------------- | :---------: | :----: | :----: | :--------: | :------: |
| Steer a running turn         |     Yes     |  Yes   |   —    |     —      |    —     |
| Fork from a reply            |   Native    | Native |  Copy  |    Copy    |   Copy   |
| Context meter                |     Yes     |  Yes   |   —    |     —      |   Yes    |
| **Approve for me**           | Some models |  Yes   |   —    |     —      |    —     |
| Continue after a usage limit |     Yes     |  Yes   |   —    |     —      |    —     |

A message sent mid-turn waits in a queue or steers the run, depending on **Follow-up behavior** in
**Settings → Chat**; `mod+enter` does the opposite once. Agents that can't steer always queue.

When a Claude or Codex subscription limit stops a chat, Glade can wait for the reset and send a
message asking the agent to carry on. Turn that off with **Continue after usage limits** in
**Settings → Chat**.

## Switch agents mid-task

Plan with Claude Code, let Codex implement, ask Cursor for a review. Pick a model from another agent
in the model picker and your next message carries the chat over. The transcript, files and working
tree stay where they are; only the agent changes.

### What the new agent receives

No summary written by a model. Glade sends the conversation's own messages and tool results: your
original request, the latest request and reply, then as much recent history as fits. The previous
agent's session is kept, so switching back picks up where it left off.

Every switch leaves a divider such as **Continued with Codex**; open it to see exactly what was sent.
If the previous agent still has background tasks running, a notice above the composer warns that
sending will stop them.

## Fork, compact and delegate

### Fork from a reply

Use the fork action under any finished reply, or `/fork`, to try another direction and keep the
original. Choose whether the fork works locally or in a new worktree. Codex and Claude Code fork their
own conversation; the others start a fresh session from a copy of the chat.

### Compact a long chat

The context meter shows how full the agent's context window is, where the agent reports it.
`/compact`, or **Compact now** from the meter, replaces the history with the agent's own summary.

### Subagents

Some agents start helpers for parts of a task. Ask for it in plain words; the agent decides how to
split the work. Helpers appear in a strip in the chat and under **Environment → Subagents**, where you
can follow each one's transcript and approvals. Steering the main chat leaves them running; **Stop**
ends them too.

## Under the hood

Every agent session in Glade gets Glade's own tools through a local MCP server named `glade`, next to
the agent's built-in tools. They let one chat run others:

| Tool                                           | What the agent can do                          |
| ---------------------------------------------- | ---------------------------------------------- |
| `glade_create_thread`, `glade_create_threads`  | Start new chats, on the agent it picks.        |
| `glade_send_message`, `glade_wait_for_threads` | Follow up with a chat and wait for its result. |
| `glade_read_thread`, `glade_read_thread_diff`  | Read another chat's transcript and changes.    |
| `glade_fork_thread`, `glade_interrupt_thread`  | Fork a chat or stop its running turn.          |
| `glade_open_in_app`                            | Open a file, diff or terminal in your window.  |

The [browser](/features/browser#under-the-hood), [Computer Use](/features/computer-use#under-the-hood)
and [visual replies](/features/visual-replies#under-the-hood) arrive through the same server.