> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/cline/cline/llms.txt
> Use this file to discover all available pages before exploring further.

# Interactive mode

> Use Cline's terminal TUI for hands-on development — keyboard shortcuts, slash commands, file mentions, and Plan/Act modes.

Interactive mode provides a full terminal UI for working with Cline conversationally. Unlike headless mode, which runs a single task and exits, interactive mode keeps a session open for back-and-forth collaboration: ask questions, review plans, approve actions, and iterate until the task is done.

For automated workflows, scripts, and CI/CD pipelines, see [headless mode](/cline-cli/headless-mode) instead.

## When to use interactive mode

Interactive mode is the right choice when you:

* **Don't know exactly what you need yet** — explore a codebase, ask questions, and understand the architecture before making changes
* **Want to review before acting** — switch to Plan mode to see Cline's strategy, then commit to Act mode when you're ready
* **Need iterative refinement** — build on previous responses, ask follow-up questions, and guide Cline to the right solution
* **Prefer human oversight** — review each proposed action, approve file writes, and stay in control of what changes
* **Are working on complex tasks** — multi-step refactoring, debugging sessions, or feature development that requires judgment

## Starting interactive mode

Run `cline` with no arguments:

```bash theme={null}
cline
```

You'll see an animated welcome screen. Type your task in the input field at the bottom and press Enter.

You can also start with an initial task, which will be submitted automatically once the UI loads:

```bash theme={null}
cline "Help me add authentication to this Express app"
```

## Keyboard shortcuts

All navigation and control in the terminal UI is done via keyboard.

### Mode controls

| Shortcut    | Action                               |
| ----------- | ------------------------------------ |
| `Tab`       | Toggle between Plan and Act mode     |
| `Shift+Tab` | Toggle auto-approve all actions      |
| `Esc`       | Exit or cancel the current operation |

### Input controls

| Shortcut       | Action                              |
| -------------- | ----------------------------------- |
| `Enter`        | Submit your message                 |
| `↑` / `↓`      | Navigate message history            |
| `Home` / `End` | Move cursor to start or end of line |
| `Ctrl+A`       | Move cursor to beginning of line    |
| `Ctrl+E`       | Move cursor to end of line          |
| `Ctrl+W`       | Delete the word before the cursor   |
| `Ctrl+U`       | Delete the entire line              |

### Session controls

| Shortcut | Action                                         |
| -------- | ---------------------------------------------- |
| `Ctrl+C` | Exit interactive mode and show session summary |

## File mentions with `@`

Type `@` followed by a filename to include a file from your workspace as context:

```text theme={null}
@src/utils.ts can you add error handling to this file?
```

As you type after `@`, Cline shows a fuzzy-search dropdown of matching files. Use the arrow keys to navigate and `Enter` to select.

<Tip>
  File search uses ripgrep for fast matching. Partial paths work — type `@utils` to find `src/utils/helpers.ts`.
</Tip>

You can include multiple file references in a single message:

```text theme={null}
Compare @src/old-api.ts with @src/new-api.ts and list the breaking changes
```

## Slash commands

Type `/` to see available commands. Built-in slash commands:

| Command     | Description                                           |
| ----------- | ----------------------------------------------------- |
| `/settings` | Open the settings panel                               |
| `/models`   | Switch models without leaving the session             |
| `/history`  | Browse and resume previous tasks                      |
| `/clear`    | Start a fresh task, clearing the current conversation |
| `/help`     | Show available commands                               |
| `/exit`     | Exit the CLI                                          |

If you have [workflows](/customization/workflows) configured, they appear as additional slash commands. For example, a workflow named `code-review` becomes `/code-review`.

## Settings panel

Open the settings panel with `/settings`. Navigate between tabs using the arrow keys.

| Tab              | What you can configure                                                 |
| ---------------- | ---------------------------------------------------------------------- |
| **API**          | Provider, model, extended thinking toggle, thinking budget             |
| **Auto-approve** | Per-action approval rules: reads, writes, commands, browser, MCP tools |
| **Features**     | Hooks, skills, auto-compact, sound notifications                       |
| **Account**      | Sign in or out, view subscription status                               |
| **Other**        | Theme, debug options                                                   |

## Plan and Act modes

Press `Tab` to toggle between Plan and Act mode. These work the same way as in the VS Code extension — see [Plan and Act](/core-workflows/plan-and-act) for a detailed explanation.

### Plan mode

In Plan mode, Cline analyzes your request and outlines a strategy before making any changes. Use this when:

* Exploring a new or unfamiliar codebase
* Working on a large refactor where you want to agree on the approach first
* You want to catch misunderstandings before any files are touched

### Act mode

In Act mode, Cline executes tasks directly. Use this when:

* The task is straightforward and well-defined
* You've already reviewed the plan and are ready to proceed
* Speed matters more than pre-verification

<Tip>
  A common workflow: start in Plan mode to review the strategy, then press `Tab` to switch to Act mode when you're satisfied.
</Tip>

## Auto-approve

Press `Shift+Tab` to toggle auto-approve for all actions. When enabled, Cline skips the per-action confirmation prompts and works continuously without interruption.

### When to enable auto-approve

* The task is well-defined and you trust the outcome
* The task has many steps and constant approval prompts would slow you down significantly
* You're watching the output in real time and can press `Ctrl+C` to stop if something goes wrong

### What gets auto-approved

With auto-approve enabled, the following happen without prompting:

* File reads
* File writes
* Shell command execution
* Browser actions
* MCP tool calls

For granular control — for example, auto-approving reads but not writes — use `/settings` → **Auto-approve** tab, or see [Auto-approve](/features/auto-approve).

<Warning>
  Auto-approve gives Cline full autonomy over your working directory. Run on a clean git branch so you can revert changes easily. Press `Ctrl+C` at any time to stop immediately.
</Warning>

## Session summary

When you exit with `Ctrl+C`, Cline displays a session summary:

* Tasks completed
* Files modified
* Commands executed
* Token usage and cost

This helps you track what was accomplished during the session.

## Running multiple instances

By default, all CLI instances share the same configuration directory (`~/.cline/data/`). To run isolated instances with separate providers, API keys, and task history, use the `--config` flag:

```bash theme={null}
# Work instance with team configuration
cline --config ~/.cline-work

# Personal instance with a different model
cline --config ~/.cline-personal

# Isolated instance for testing new settings
cline --config ~/.cline-test
```

Each config directory maintains its own provider settings, API keys, task history, and preferences.

<Tip>
  Use a terminal multiplexer like tmux or a split-pane terminal to run multiple Cline instances in parallel, each working on a different part of your project with different models or configurations.
</Tip>

## Tips for effective use

**Give Cline context upfront.** Describe what you're working on and reference relevant files:

```text theme={null}
I'm building a REST API with Express. Routes are in @src/routes/ and models in @src/models/.
Help me add JWT authentication.
```

**Use Plan mode when you're unsure of the approach:**

```text theme={null}
[Tab to switch to Plan mode]
How should I structure the database schema for a multi-tenant SaaS app?
```

**Build on previous messages.** The session preserves full conversation context:

```text theme={null}
> Add a login endpoint
[Cline creates the endpoint]

> Now add rate limiting to that endpoint
[Cline modifies the same endpoint]

> Add tests for both features
[Cline creates test files]
```

## Next steps

<CardGroup cols={2}>
  <Card title="Headless mode" icon="robot" href="/cline-cli/headless-mode">
    Run Cline autonomously in scripts and CI/CD pipelines.
  </Card>

  <Card title="CLI reference" icon="book" href="/cline-cli/cli-reference">
    Complete documentation for all commands and flags.
  </Card>
</CardGroup>