> ## Documentation Index
> Fetch the complete documentation index at: https://ade-ac1c6011-ade-im-seeing-error-messag-eright-58df792e.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent Chat Overview

> Conversational AI with real project access — read files, run commands, create PRs, spawn worker runs, and capture proof artifacts, all from a single chat interface.

## What is Agent Chat?

**Agent Chat** is ADE's conversational interface for AI agents wired into your development environment. The agent reads and writes real files, runs terminal commands, creates branches and PRs, queries your context pack, and can escalate to a Worker run when the task outgrows a single session. Every chat session is recorded with a full transcript, tool call log, and timing data.

### Supported providers

Agent Chat works across multiple provider backends:

| Provider     | Backend                         | Auth                                   |
| ------------ | ------------------------------- | -------------------------------------- |
| **Claude**   | Anthropic SDK v2 sessions       | CLI subscription or API key            |
| **Codex**    | OpenAI app-server JSON-RPC      | CLI subscription or API key            |
| **Cursor**   | Cursor SDK                      | Cursor API key                         |
| **OpenCode** | OpenCode server (local process) | API key, OpenRouter, or local endpoint |

ADE detects which providers are available and lets you switch between them per-session using the model selector in the chat header. Each provider has its own session lifecycle, timeout behavior, and interrupt semantics.

<CardGroup cols={2}>
  <Card title="What Chat is for" icon="message">
    Exploratory work, targeted edits, quick Q\&A about your codebase, PR creation, test runs, and anything that resolves in a single focused session.
  </Card>

  <Card title="When to escalate to a Worker run" icon="target">
    Tasks spanning multiple files or agents, work requiring a formal audit trail, or anything you expect to run for more than 15–20 minutes.
  </Card>
</CardGroup>

***

## Chat Scoping

Chat in ADE is always scoped — it operates within a defined context boundary that determines what the agent can access and what its tool calls affect.

<Tabs>
  <Tab title="Lane Chat">
    **Lane chat** is the most common mode. It is opened from within a specific Lane view and anchors the agent to that lane's context:

    * File reads and writes are scoped to the lane's git worktree
    * Terminal commands run in the lane's terminal session
    * Git operations affect the lane's branch
    * Context is seeded from the lane's pack (recent activity, file map, open PRs)

    Lane chat is how you do day-to-day development work with an agent.
  </Tab>

  <Tab title="CTO Chat">
    The **CTO chat** operates at project scope. The CTO agent has access to:

    * Project-wide context (all lanes, all branches, all pack snapshots)
    * Linear sync — it can read and write issues
    * Delegation — it can spawn worker agents or new worker runs
    * Architecture decisions recorded in the project pack

    Use CTO chat for cross-cutting questions, planning, and delegation rather than hands-on coding.
  </Tab>

  <Tab title="Worker run Chat">
    **Worker run chat** is embedded inside a Worker run's detail view. It is a direct channel to the worker run's orchestrator while the worker run is running. Use it to:

    * Ask the orchestrator for a status summary
    * Provide additional context mid-worker run
    * Redirect a worker that has gone off course

    Worker run chat does not start new work — it communicates with the orchestrator of an already-running worker run.
  </Tab>
</Tabs>

***

## Starting a Chat

<Steps>
  <Step title="Open a Lane">
    Navigate to the lane you want to work in from the left sidebar or the Workspace Graph.
  </Step>

  <Step title="Open the Chat pane">
    Click the **Chat** button in the lane toolbar, or press `Cmd+K`. A new chat session opens with automatic context injection from the lane's pack.
  </Step>

  <Step title="Choose a model (optional)">
    The model selector in the chat header defaults to your configured preferred model. Click it to switch models for this session. ADE remembers your last-used model per lane.
  </Step>

  <Step title="Pick a permission preset (optional)">
    For CLI-wrapped models, the composer surfaces a permission picker in the header. The presets vary per provider:

    **Claude** — standard Claude CLI permission modes (plan / edit / full-auto / default), each with its own allowlist.

    **Codex** — four presets map directly to Codex's `--approval-policy` and `--sandbox` flags:

    * **Default permissions** — workspace-write sandbox, approval policy `on-request`. Edits and shell commands in the workspace run without asking; anything outside the workspace prompts for approval.
    * **Plan mode** — read-only sandbox, approval policy `on-request`. Agent can explore and answer questions; it needs approval to edit or run commands.
    * **Full access** — `danger-full-access` sandbox, approval policy `never`. No sandbox, no approvals — safe only in an externally sandboxed environment.
    * **Custom (config.toml)** — no ADE flags are passed. Codex honors `~/.codex/config.toml`.

    There is no "Guarded edit" preset anymore; **Default permissions** is the standard middle ground.
  </Step>

  <Step title="Type your first message">
    The agent receives your message along with the injected context. Tool calls begin immediately if the task requires them.

    You can also **attach images** (JPEG, PNG, GIF, or WebP) to your message using the attachment button in the composer. Images are sent inline as base64 content blocks, so the agent sees them natively — no file-read workaround required.
  </Step>
</Steps>

<Tip>
  Start a new session from an existing session's history by opening the History tab and clicking **Resume**. The previous transcript is loaded as context so the agent picks up where you left off.
</Tip>

***

## Proof Capture

Chat agents can leave **intentional evidence** of their work by calling the `ade proof` CLI — screenshots, short recordings, or ingested browser traces. There is no per-session policy chip anymore; the agent decides when a step deserves a proof, runs the CLI, and the captured artifact is linked to the chat session automatically.

Captured proofs appear in the session artifact panel and can be promoted to the lane's durable context, attached to a worker run, or published to a PR or Linear issue. See [Proof Overview](/computer-use/overview) for the full workflow.

***

## Session behavior

### Auto-titling

ADE automatically generates descriptive session titles using AI. The primary configuration namespace is `sessionIntelligence.titles`:

* `sessionIntelligence.titles.autoTitleEnabled` — toggle auto-titling on or off
* `sessionIntelligence.titles.reasoningEffort` — depth of analysis for title generation
* `sessionIntelligence.titles.refreshOnComplete` — regenerate the title when the session ends
* `sessionIntelligence.titles.modelId` — override the model used for title generation

Legacy keys `ai.chat.autoTitleEnabled` and `chat.autoTitleReasoningEffort` / `chat.autoTitleRefreshOnComplete` still function as runtime fallbacks.

### Interrupting agents

Press **Escape** or click the **Stop** button to interrupt a running agent. Behavior varies by provider:

* **Claude** — graceful interrupt; agent reports partial results
* **Codex** — issues a turn/interrupt for the active turn; partial output is preserved in the transcript
* **Cursor** — cancels the active SDK run

### Steering and editing

You can **steer** an in-progress agent by sending a follow-up message before the current turn completes. ADE queues the steer message and delivers it at the next turn boundary. You can also **edit** a previous message to re-run the conversation from that point.

### Context integration

Chat sessions receive lane, session, artifact, worker run, and explicit user context. For product or architecture knowledge, agents inspect the repository directly through ADE tools.

***

## Explore more

<CardGroup cols={2}>
  <Card title="Chat Capabilities" icon="toolbox" href="/chat/capabilities">
    What the agent can do — file operations, git, PRs, worker runs, lane and action tools via the `ade` CLI, and more.
  </Card>

  <Card title="Context & Artifacts" icon="database" href="/chat/context">
    Managing context windows, working with artifacts, chat history, and troubleshooting.
  </Card>
</CardGroup>