---
title: "Как работает Claude Code"
url: "https://romankryvolapov.com/ru/claude-code-how-it-works/"
description: "Claude Code изнутри: цикл агента, инструменты чтения, правки и поиска, контекст и его сжатие, память, правила, скилы, субагенты, хуки, MCP и плагины, что лежит в папке .claude и на диске, разрешения, песочница, браузер и управление компьютером, фоновые и облачные сессии, работа на удалённой машине и сравнение с другими харнесами."
language: ru
published: 2026-11-19
updated: 2026-11-19
---
**Привет!**

У меня на сайте уже есть три статьи про Claude Code: [справочник команд и настроек](/ru/claude-code-commands-and-settings/), [разбор хуков](/ru/claude-code-hooks/) и [практики работы](/ru/claude-code-best-practices/). Все три отвечают на вопрос «что нажать и как настроить». Эта отвечает на другой вопрос: как оно устроено внутри.

Зачем это знать. Claude Code выглядит как чат в терминале, но за чатом стоит довольно большая машина: десятки инструментов, несколько видов памяти, правила, скилы, субагенты, хуки, разрешения, песочница, фоновые и облачные сессии. Пока не понимаешь, как эти части связаны, настройки кажутся набором случайных переключателей. Когда понимаешь, большинство из них становятся очевидными.

Статья идёт от простого к сложному. Сначала — что происходит между вашим сообщением и ответом. Потом — чем агент читает, правит и ищет. Потом — всё, что живёт в папке проекта и в домашней папке на диске. Потом — безопасность и изоляция. И в конце — где всё это можно запускать: от ноутбука до виртуальной машины в сети, и чем Claude Code отличается от похожих инструментов.

Всё описанное сверено с официальной документацией и с установленной у меня версией 2.1.328 в ноябре 2026 года. Claude Code выходит несколько раз в неделю, поэтому мелкие детали меняются быстро, а устройство в целом — медленно. Пути на диске я показываю так, как они выглядят у меня на Windows, и рядом говорю, где это на macOS и Linux.

## Модель и харнес: кто что делает

Начнём с главного разделения. В Claude Code две части, и их постоянно путают.

**Модель** — это нейросеть Claude на серверах Anthropic. Она умеет одно: получить текст и выдать текст. Она не видит ваш диск, не может запустить команду и ничего не помнит между запросами.

**Харнес** (harness, «обвязка») — это программа `claude`, которая работает на вашем компьютере. Именно её вы устанавливаете. Она читает файлы, запускает команды, показывает интерфейс, спрашивает разрешения, хранит историю и решает, что отправить модели в каждом запросе.

Модель думает, харнес делает. Связаны они через **инструменты** (tools). Инструмент — это функция, которую харнес умеет выполнить: «прочитай файл», «запусти команду», «найди строку». Харнес описывает модели список инструментов, а модель в ответе может написать не обычный текст, а просьбу: «вызови инструмент чтения с таким-то путём». Харнес выполняет просьбу и возвращает модели результат.

```text
        ваш компьютер                          серверы Anthropic
┌──────────────────────────────┐            ┌────────────────────┐
│  харнес (программа claude)   │  запрос →  │                    │
│                              │            │   модель Claude    │
│  интерфейс, разрешения,      │  ← ответ   │                    │
│  история, настройки          │            └────────────────────┘
│            │                 │
│      инструменты             │
│  ┌─────────┬───────┬───────┐ │
│  │ файлы   │ shell │ веб   │ │
│  └─────────┴───────┴───────┘ │
└──────────────────────────────┘
```

Из этой схемы следует вывод, который пригодится дальше много раз. Ваш код не «загружается в Claude». Он лежит на диске, и на серверы уходит только то, что харнес положил в запрос: ваши сообщения, прочитанные файлы, вывод команд. Всё остальное модель не видела.

И второй вывод. Одна и та же модель в разных харнесах работает по-разному, потому что у них разные инструменты, разные системные инструкции и по-разному устроена работа с контекстом. Насколько сильно это влияет на результат, я разбирал в [сравнении харнесов](/ru/ai-agent-harnesses/).

## Цикл агента: что происходит после Enter

Обычный чат устроен так: вопрос — ответ. Агент устроен иначе: вопрос — много шагов — ответ. Эти шаги называют циклом агента.

Разберём на примере. Вы написали: «тест авторизации падает, почини».

1. Харнес собирает запрос: системные инструкции, описания инструментов, инструкции проекта, вашу фразу. Отправляет модели.
2. Модель отвечает не текстом, а вызовом инструмента: «запусти тесты авторизации».
3. Харнес проверяет, можно ли это делать без спроса. Если нельзя — спрашивает вас. Потом запускает команду и получает вывод.
4. Харнес отправляет модели новый запрос: всё прежнее плюс вывод тестов.
5. Модель видит ошибку и просит найти в коде функцию, которая упала. Харнес ищет и возвращает результат.
6. Модель просит прочитать файл. Потом просит заменить в нём одну строку на другую. Потом снова запустить тесты.
7. Тесты прошли. Модель отвечает обычным текстом: что было не так и что она поправила. Вызовов инструментов в ответе нет — ход закончен.

Документация описывает этот цикл тремя фазами: **собрать контекст → действовать → проверить результат**. Фазы не идут строго по очереди: что делать дальше, модель решает после каждого шага, глядя на то, что вернул предыдущий.

Три детали, которые стоит знать.

**Каждый запрос несёт весь разговор целиком.** Модель ничего не помнит между запросами, поэтому на шаге 6 харнес заново отправляет ей всё с шага 1. Отсюда растёт вся тема контекста, сжатия и стоимости — о ней ниже.

**Вызовы бывают параллельными.** Если модели нужно прочитать пять файлов, она просит все пять в одном ответе, и харнес выполняет их одновременно.

**Вмешаться можно в любой момент.** Esc останавливает текущий вызов и возвращает управление вам. А если просто напечатать сообщение, пока агент работает, он прочитает его после текущих вызовов, в том же ходе. Это удобный способ поправить курс, не обрывая работу.

## Что модель видит в начале сессии

Перед вашим первым сообщением в запросе уже лежит довольно много. Важно понимать, что именно, потому что каждая строка там оплачивается в каждом запросе и влияет на поведение.

| Что | Откуда берётся | Когда загружается |
|---|---|---|
| Системный промпт | встроен в Claude Code | всегда |
| Описания встроенных инструментов | встроены | всегда |
| Сведения об окружении | рабочая папка, ОС, ветка git, незакоммиченные изменения, последние коммиты | всегда |
| Инструкции проекта | файлы `CLAUDE.md` и правила без привязки к путям | всегда |
| Авто-память | начало файла `MEMORY.md` | всегда |
| Список скилов | только имя и описание каждого | всегда; тело — по вызову |
| MCP-серверы | только имена инструментов и инструкции сервера | всегда; схемы — по требованию |
| Стиль вывода | выбранный output style | если задан |

Тонкость про инструкции проекта. `CLAUDE.md` не становится частью системного промпта. Он приходит модели как сообщение пользователя сразу после системного промпта. Поэтому это именно инструкции, которым модель обычно следует, а не жёсткая конфигурация. Для того, что должно выполняться всегда и без исключений, есть хуки и правила разрешений — механизмы харнеса, а не текста.

Посмотреть, из чего состоит контекст прямо сейчас, можно командой `/context`: она рисует сетку и показывает, сколько занимают инструменты, память, скилы и сам разговор.

## Инструменты: чем агент работает

Инструментов больше тридцати. Запоминать все не нужно, но основные полезно знать по именам: эти же имена пишутся в правилах разрешений и в хуках.

| Группа | Инструменты | Спрашивают разрешение |
|---|---|---|
| Файлы | `Read`, `Edit`, `Write`, `NotebookEdit` | чтение — нет, правка — да |
| Поиск | `Grep`, `Glob`, `LSP` | нет |
| Команды | `Bash`, `PowerShell`, `Monitor` | да, кроме заведомо безопасных команд |
| Веб | `WebFetch`, `WebSearch` | да |
| Агенты | `Agent`, `SendMessage`, `ListAgents`, `Workflow` | в основном нет |
| Планирование | `EnterPlanMode`, `ExitPlanMode`, `TaskCreate` и другие, `AskUserQuestion` | нет |
| Расширения | `Skill`, `ToolSearch`, инструменты MCP-серверов | зависит от скила и сервера |
| Расписание | `CronCreate`, `CronList`, `CronDelete`, `ScheduleWakeup` | нет |
| Рабочие копии | `EnterWorktree`, `ExitWorktree` | вход — да |

Теперь по порядку о тех, из которых состоит почти вся работа.

### Чтение файлов

Все примеры этого раздела сняты с маленького учебного проекта. В нём пять файлов: модуль сессий, два обработчика API, тест и собранный бандл в папке `dist`, которая внесена в `.gitignore`.

```text
demo/
├── .gitignore            node_modules/ и dist/
├── dist/bundle.js
├── src/
│   ├── auth/session.ts
│   └── api/
│       ├── login.ts
│       └── profile.ts
└── tests/session.test.ts
```

Вызов инструмента — это JSON с параметрами: именно в таком виде модель его и отправляет, а имя инструмента я подписываю над блоком. Перевод строки внутри значения записывается как `\n`, это обычное правило JSON. Ответы показаны такими, какими их вернул харнес; длинные абсолютные пути сокращены до относительных.

`Read` принимает путь к файлу и возвращает его содержимое. У каждой строки слева стоит её номер:

```json title="вызов Read"
{
  "file_path": "src/auth/session.ts"
}
```

```typescript title="ответ Read"
1	import { db } from '../db';
2	
3	const TTL = 60 * 60;
4	
5	export function createSession(userId: string) {
6	  const token = crypto.randomUUID();
7	  db.sessions.insert({ token, userId, expiresAt: Date.now() + TTL * 1000 });
8	  return token;
9	}
10	
11	export function findSession(token: string) {
12	  const session = db.sessions.find(token);
13	  if (!session) {
14	    return null;
15	  }
16	  if (session.expiresAt < Date.now()) {
17	    return null;
18	  }
19	  return session;
20	}
```

Номера строк нужны модели, чтобы ориентироваться и ссылаться на место в файле. В сам файл они, конечно, не входят, и при правке модель обязана их отбросить.

Большой файл целиком читать незачем. У `Read` есть два необязательных параметра: с какой строки начать и сколько строк взять. Так агент читает только нужную функцию:

```json title="вызов Read"
{
  "file_path": "src/auth/session.ts",
  "offset": 11,
  "limit": 6
}
```

```typescript title="ответ Read"
11	export function findSession(token: string) {
12	  const session = db.sessions.find(token);
13	  if (!session) {
14	    return null;
15	  }
16	  if (session.expiresAt < Date.now()) {
```

Обычно это выглядит так: поиск сообщил, что нужное находится в строке 340 файла на две тысячи строк, и агент читает строки с 320 по 380, а не весь файл.

Ограничения такие. За один вызов возвращается до 25 тысяч токенов. Файл больше 256 КБ целиком без явного указания не читается: агент получит отказ и прочитает его частями. Если файла нет, ответ — обычная ошибка, и модель видит её как результат вызова:

```text languages="ответ Read"
File does not exist. Note: your current working directory is D:\projects\demo.
```

На эту подсказку про рабочую папку стоит обратить внимание. Самая частая причина такой ошибки — относительный путь, посчитанный не от той папки. Поэтому инструменты работы с файлами требуют абсолютных путей.

Читает `Read` не только текст. Картинку (PNG, JPEG, GIF, WebP) модель увидит как изображение: так агент смотрит на скриншоты и макеты. PDF читается постранично, блокнот Jupyter — ячейками вместе с выводом. Двоичные форматы вроде `.xlsx` или `.zip` инструмент не откроет: для них агент пишет небольшой скрипт.

### Редактирование: точная замена строки

Это самая неочевидная часть, и на ней стоит задержаться.

Агент не переписывает файл целиком и не создаёт патч в формате diff. Инструмент `Edit` принимает три вещи: путь, старый фрагмент и новый фрагмент. Харнес находит в файле старый фрагмент и заменяет его новым.

Самый простой случай — поменять одну строку. Сессия должна жить сутки, а не час:

```json title="вызов Edit"
{
  "file_path": "src/auth/session.ts",
  "old_string": "const TTL = 60 * 60;",
  "new_string": "const TTL = 60 * 60 * 24;"
}
```

```text languages="ответ Edit"
The file src/auth/session.ts has been updated successfully.
```

Ответ короткий: содержимое файла обратно не возвращается. Модель и так знает, что теперь в файле, потому что сама написала новый фрагмент.

У этой схемы три правила, и все три — защита от тихой порчи кода. Разберём каждое на примере.

**Правило первое: совпадение точное.** Никаких регулярных выражений и «примерно похоже». Допустим, модель по памяти решила, что в файле написано `const TTL = 3600;`:

```json title="вызов Edit"
{
  "file_path": "src/auth/session.ts",
  "old_string": "const TTL = 3600;",
  "new_string": "const TTL = 86400;"
}
```

```text languages="ответ Edit"
String to replace not found in file.
String: const TTL = 3600;
```

Правка не применилась, файл не тронут. Модель видит ошибку, перечитывает файл и повторяет вызов уже с настоящим текстом. То же случится, если отличается хотя бы один пробел в отступе или табуляция стоит вместо пробелов. Это раздражает, когда смотришь со стороны, но альтернатива хуже: «умная» замена по приблизительному совпадению иногда попадала бы не в то место, и вы узнали бы об этом через неделю.

**Правило второе: фрагмент должен встречаться в файле один раз.** В нашем файле строка `return null;` есть дважды. Попробуем заменить её:

```json title="вызов Edit"
{
  "file_path": "src/auth/session.ts",
  "old_string": "    return null;",
  "new_string": "    return undefined;"
}
```

```text languages="ответ Edit"
Found 2 matches of the string to replace, but replace_all is false.
To replace all occurrences, set replace_all to true. To replace only one
occurrence, please provide more context to uniquely identify the instance.
String:     return null;
```

Харнес не стал угадывать, какое из двух мест имелось в виду. Дальше у модели два пути.

Если нужно одно конкретное место, она берёт в `old_string` больше окружающего кода — столько, чтобы фрагмент стал единственным. Например, нужно удалять просроченную сессию перед возвратом. Строку `return null;` модель захватывает вместе с условием над ней:

```json title="вызов Edit"
{
  "file_path": "src/auth/session.ts",
  "old_string": "  if (session.expiresAt < Date.now()) {\n    return null;",
  "new_string": "  if (session.expiresAt < Date.now()) {\n    db.sessions.delete(token);\n    return null;"
}
```

Теперь фрагмент из двух строк встречается в файле один раз, и правка проходит. Заметьте, что `new_string` повторяет неизменённые строки: инструмент не «вставляет строку», он заменяет один кусок текста другим.

Если же нужны все вхождения — например, при переименовании переменной в пределах файла — модель ставит флаг:

```json title="вызов Edit"
{
  "file_path": "src/auth/session.ts",
  "old_string": "session",
  "new_string": "userSession",
  "replace_all": true
}
```

Здесь виден и подвох: такая замена затронет и `db.sessions`, превратив его в `db.userSessions`. Замена текстовая, о синтаксисе языка она ничего не знает. Поэтому для переименований по всему проекту агент обычно берёт инструмент языкового сервера, а не текстовую замену.

**Правило третье: сначала прочитать, потом править.** Изначально оно было жёстким: правка файла, который не читался в этом разговоре, отклонялась. Смысл в том, чтобы модель правила то, что реально лежит на диске, а не то, что ей кажется. У новейших моделей требование ослаблено: если содержимое уже известно — из вывода поиска или команды `cat` — отдельное чтение не обязательно. На более старых моделях оно требуется всегда, а для блокнотов Jupyter и для файлов, прочитанных только частично, — на любых.

Отсюда же следует ещё одна защита. Если между чтением и правкой файл изменился на диске — вы сохранили его в редакторе или сработал форматтер — фрагмент из `old_string` может уже не найтись, и правка честно упадёт с ошибкой «не найдено», а не затрёт ваши изменения.

**Несколько правок в одном файле** — это несколько вызовов подряд. Каждый следующий работает уже с изменённым файлом. Поэтому модель следит, чтобы вторая правка не искала текст, который первая только что заменила.

Почему не diff. Формат diff требует от модели точно посчитать номера строк, а в счёте модели ошибаются. Замена «найди этот текст» номеров не требует вообще, и ошибка в ней всегда громкая: либо фрагмент нашёлся ровно один раз, либо правки нет.

#### Создание и перезапись: Write

`Write` принимает путь и полное содержимое. Если файла нет, он создаётся вместе с недостающими папками. Если есть — перезаписывается целиком.

```json title="вызов Write"
{
  "file_path": "src/auth/cleanup.ts",
  "content": "import { db } from '../db';\n\nexport function removeExpired() {\n  db.sessions.deleteWhere((s) => s.expiresAt < Date.now());\n}\n"
}
```

Дописать в конец файла этим инструментом нельзя: он всегда кладёт весь текст. Поэтому для правки существующего файла почти всегда выбирается `Edit`, и причин две. Во-первых, цена: чтобы поменять одну строку в файле на тысячу строк через `Write`, модели пришлось бы заново напечатать всю тысячу. Во-вторых, риск: перепечатывая большой файл, модель может незаметно потерять или «улучшить» кусок, который трогать не просили. `Edit` физически не может изменить ничего, кроме названного фрагмента.

`Write` остаётся для двух случаев: новый файл и полное переписывание, когда от старого содержимого почти ничего не остаётся.

#### Удаление, переименование, перенос

Отдельных инструментов для этого нет. Удалить файл, переименовать его или перенести в другую папку агент может только командой оболочки: `rm`, `mv`, `git mv`. Это важно по двум причинам. Такие действия идут через разрешения для команд, а не для правок. И откат по чекпоинтам их не видит — об этом в разделе про откат.

#### Что вы видите в интерфейсе

Каждую правку харнес показывает как привычный diff: красным убранные строки, зелёным добавленные. В ручном режиме под ним вопрос с тремя вариантами: применить, применить и больше не спрашивать про правки в этой сессии, отказать и объяснить агенту, что не так. Отказ с объяснением — нормальный рабочий инструмент: агент получает ваш текст как результат вызова и делает иначе.

Если открыта IDE с расширением, diff показывается в окне редактора, а не в терминале.

А перед каждой правкой харнес сохраняет прежнюю версию файла — об этом в разделе про откат.

### Поиск: индекса нет

Многие ждут, что агент при первом запуске «индексирует проект»: строит базу эмбеддингов или граф кода, как это делают некоторые редакторы. Claude Code этого не делает. Постоянного индекса у него нет.

Вместо этого агент ищет так же, как искал бы человек в терминале, только быстрее и настойчивее:

Инструментов поиска два: один ищет файлы по имени, другой — по содержимому.

**`Glob` — поиск по имени.** Принимает маску пути и возвращает список файлов:

```json title="вызов Glob"
{
  "pattern": "**/*.ts"
}
```

```text languages="ответ Glob"
src/auth/session.ts
src/api/login.ts
src/api/profile.ts
tests/session.test.ts
```

Две звёздочки означают «любая глубина вложенности». Результат отсортирован по времени изменения, и выдаётся не больше ста файлов. Типичные маски: `src/**/*.test.ts` — все тесты, `**/package.json` — все пакеты монорепозитория, `**/*config*` — всё, что похоже на конфигурацию.

**`Grep` — поиск по содержимому.** Принимает регулярное выражение. Внутри это ripgrep, очень быстрая утилита поиска. У него три режима, и агент выбирает их по очереди, от дешёвого к подробному.

Первый режим — только имена файлов. Он включён по умолчанию и почти ничего не стоит по токенам. Вопрос «где вообще используется эта функция»:

```json title="вызов Grep"
{
  "pattern": "findSession"
}
```

```text languages="ответ Grep"
Found 3 files
tests/session.test.ts
src/api/profile.ts
src/auth/session.ts
```

Обратите внимание: в папке `dist` лежит бандл, где это слово тоже есть, но в выдачу он не попал. Папка внесена в `.gitignore`, а `Grep` игнорируемые файлы пропускает.

Второй режим — сами строки с номерами и соседними строками для контекста. Здесь же поиск сужается маской: только исходники, без тестов. Скобка в образце экранирована, потому что это регулярное выражение:

```json title="вызов Grep"
{
  "pattern": "findSession\\(",
  "glob": "src/**/*.ts",
  "output_mode": "content",
  "-C": 1
}
```

```text languages="ответ Grep"
src/api/profile.ts-3-export function profile(token: string) {
src/api/profile.ts:4:  const session = findSession(token);
src/api/profile.ts-5-  return session ? { userId: session.userId } : null;
--
src/auth/session.ts-10-
src/auth/session.ts:11:export function findSession(token: string) {
src/auth/session.ts-12-  const session = db.sessions.find(token);
```

Строка с двоеточиями — совпадение, строки с дефисами — контекст вокруг. Параметр `-C: 1` означает одну строку до и одну после. Этого часто хватает, чтобы понять место, не открывая файл.

Третий режим — количество. Вопрос «сколько раз это встречается»:

```json title="вызов Grep"
{
  "pattern": "return null",
  "output_mode": "count"
}
```

```text languages="ответ Grep"
src/auth/session.ts:2

Found 2 total occurrences across 1 file.
```

Так агент оценивает масштаб до начала работы: одно дело поправить два места, другое — двести.

Дальше агент читает найденное и, если нужно, ищет снова, уже точнее. На реальной задаче это цепочка из нескольких шагов: найти определение функции → найти, кто её вызывает → прочитать вызывающий код → найти тесты.

Такой подход называют агентным поиском. У него есть цена: каждый поиск — это шаг цикла и токены. И есть преимущества: нет индекса, который устаревает, результат всегда соответствует диску, и ничего из вашего кода не уходит в стороннюю базу.

Две детали, которые экономят время, когда агент «не находит очевидное»:

- `Grep` пропускает файлы из `.gitignore`. `Glob` по умолчанию не пропускает. Поэтому файл из игнорируемой папки находится по имени, но не по содержимому.
- На macOS, Linux и в WSL отдельных инструментов `Grep` и `Glob` в наборе нет: там агент пользуется командами `find` и `grep` через shell, а Claude Code подставляет под них встроенные быстрые реализации. На Windows это отдельные инструменты. Поведение одно, названия в логах разные.

Если хочется именно семантики — «найди все места, где вызывается этот метод», а не «найди текст» — для этого есть инструмент `LSP`. Он подключает языковой сервер, тот же, что работает в вашей IDE, и даёт переход к определению, поиск ссылок и ошибки типов сразу после правки. Включается плагином под конкретный язык; об этом в разделе про плагины.

### Команды: Bash и PowerShell

`Bash` выполняет команду оболочки и возвращает вывод. Через него агент делает всё, для чего нет отдельного инструмента: сборка, тесты, git, пакетные менеджеры, скрипты.

Как он себя ведёт:

- **Каждая команда — отдельный процесс.** Переменные окружения из одной команды в следующую не переходят. Рабочая папка переходит, пока вы внутри проекта; вышли за его пределы — следующая команда снова стартует из проекта.
- **Ваш профиль подхватывается.** При старте сессии Claude Code снимает слепок вашей оболочки — алиасы, функции, настройки — и применяет его к командам.
- **Есть таймаут.** По умолчанию две минуты, модель может попросить до десяти.
- **Длинное уходит в фон.** Сборку или сервер агент запускает в фоне и продолжает работать; когда процесс завершится, харнес сообщит ему об этом. Команда, которая не уложилась в таймаут, тоже переезжает в фон сама.
- **Вывод обрезается.** Модели сразу достаётся около 30 тысяч символов. Остальное сохраняется в файл, и агент читает из него нужные куски. Так лог сборки на мегабайт не съедает контекст.

Пара примеров. Вот как выглядит правило про рабочую папку. Агент перешёл во временный каталог за пределами проекта и выполнил там команду:

```json title="вызов Bash"
{
  "command": "cd /tmp/build && ls"
}
```

```text languages="ответ Bash"
bundle.js
Shell cwd was reset to D:\projects\demo
```

Последнюю строку добавил харнес: команда отработала, но следующая снова начнётся из папки проекта. Так агент не может «заблудиться» и случайно выполнить `rm` не там.

А вот запуск в фоне. Сервер разработки не завершается сам, поэтому ждать его конца бессмысленно:

```json title="вызов Bash"
{
  "command": "npm run dev",
  "run_in_background": true
}
```

Харнес сразу возвращает управление и идентификатор фоновой задачи. Вывод сервера пишется в файл, и агент читает его обычным `Read`, когда нужно посмотреть, что там произошло. Список фоновых задач показывает команда `/tasks`; там же их можно остановить.

На Windows `Bash` — это Git Bash из Git for Windows. Рядом работает инструмент `PowerShell`; без установленного Git он остаётся единственной оболочкой. Отсюда типичная путаница: синтаксис у них разный, и команда, написанная для одного, в другом не работает.

Ещё есть `Monitor`: он запускает команду в фоне и передаёт агенту её вывод построчно, по мере появления. Удобно, чтобы следить за логом или ждать события, не опрашивая в цикле.

Команду можно выполнить и самому, не выходя из сессии: строка, начатая с `!`, запускается в оболочке, а её вывод попадает в разговор.

### Веб

`WebSearch` возвращает заголовки и адреса из поискового бэкенда Anthropic. Сами страницы он не скачивает.

`WebFetch` скачивает страницу, но работает хитрее, чем кажется. Он превращает HTML в Markdown и отдаёт его **другому, отдельному** запросу к небольшой модели вместе с вопросом. Основной агент получает уже ответ на вопрос, а не сырую страницу. Смысла два: большая страница не забивает контекст, и вредные инструкции, спрятанные в тексте страницы, не попадают основному агенту напрямую. Оборотная сторона: это пересказ, и точные цифры из таблицы он иногда путает. Когда нужна дословная точность, агенту лучше скачать страницу командой `curl`.

Для сайтов, которым нужен вход или JavaScript, эти два инструмента не годятся. Там нужен настоящий браузер — о вариантах ниже.

### Одна задача целиком

Теперь соберём инструменты вместе. Задача на том же учебном проекте: «сделай, чтобы сессия жила сутки, и чтобы просроченные удалялись из базы». Вот что делает агент, шаг за шагом.

| Шаг | Вызов | Зачем | Что вернулось |
|---|---|---|---|
| 1 | `Grep` по слову `TTL` | найти, где задан срок жизни | один файл: модуль сессий |
| 2 | `Read` этого файла | увидеть код целиком, он короткий | двадцать строк с номерами |
| 3 | `Grep` по `findSession` | понять, кого заденет изменение | три файла: сам модуль, обработчик профиля, тест |
| 4 | `Read` обработчика и теста, двумя вызовами сразу | проверить, что они ждут от функции | оба файла |
| 5 | `Edit`: строка с `TTL` | сутки вместо часа | «updated successfully» |
| 6 | `Edit`: условие с просроченной сессией | добавить удаление | «updated successfully» |
| 7 | `Bash`: запуск тестов | проверить результат | вывод тестов |
| 8 | ответ текстом | рассказать, что сделано | — |

На что здесь стоит посмотреть.

**Агент начал с поиска, а не с чтения всего подряд.** В проекте на тысячу файлов он точно так же прочитал бы три.

**Шаг 3 сделан до правки.** Прежде чем менять поведение функции, агент выяснил, кто ею пользуется. Если бы обработчик профиля полагался на то, что просроченная сессия остаётся в базе, это выяснилось бы здесь, а не после.

**На шаге 4 два вызова ушли одним ответом.** Чтения друг от друга не зависят, и харнес выполнил их одновременно.

**На шаге 6 пришлось взять две строки.** Одна строка `return null;` в файле не уникальна — это тот самый случай из раздела про правку.

**Шаг 7 замыкает цикл.** Без него агент остановился бы на «выглядит правильно». С ним — на «тесты прошли». Если бы тест упал, вывод вернулся бы модели, и цикл пошёл бы дальше: прочитать ошибку, поправить, запустить снова.

Всего восемь запросов к модели. И каждый следующий нёс в себе всё предыдущее: к восьмому в запросе лежали оба поиска, три прочитанных файла, две правки и вывод тестов. Это и есть содержимое контекста, о котором следующий раздел.

## Контекст: окно, сжатие и цена

Контекстное окно — это предел объёма одного запроса к модели. В него должно поместиться всё: системный промпт, инструкции, весь разговор, каждый прочитанный файл и вывод каждой команды.

У нынешних моделей окно — миллион токенов. Этого хватает на часы работы, и упереться в предел трудно. Но окно всё равно наполняется, и тогда срабатывает **сжатие** (compaction): Claude Code просит модель пересказать разговор и заменяет историю этим пересказом. Работа продолжается, но с краткой версией прошлого.

Здесь важно знать, что сжатие переживает, а что нет.

| Переживает | Не переживает как есть |
|---|---|
| системный промпт и стиль вывода | дословные формулировки ранних сообщений |
| корневой `CLAUDE.md` и правила без привязки к путям — перечитываются с диска | правила с привязкой к путям и `CLAUDE.md` из подпапок — вернутся, когда агент снова тронет подходящий файл |
| авто-память — перечитывается с диска | содержимое прочитанных ранее файлов, кроме нескольких последних |
| список скилов | договорённости, данные только в чате |
| тела недавно вызванных скилов, с ограничением по объёму | |
| фоновые команды и субагенты — продолжают работать | |

Практический вывод простой. Всё, что должно действовать всю сессию, должно лежать в файле, а не в чате. Сказанное в чате может не пережить сжатия; записанное в инструкции проекта перечитается с диска.

Управляют этим четыре команды: `/context` показывает, чем занято окно; `/compact` сжимает сейчас, и ему можно подсказать, что сохранить; `/clear` начинает разговор с чистого листа, старый остаётся на диске; `/autocompact` задаёт порог, при котором сжатие включается само.

Теперь про цену. Раз каждый запрос несёт весь разговор, длинная сессия была бы очень дорогой. Спасает **кэш промпта**: неизменное начало запроса сервер запоминает и при повторе считает примерно в десять раз дешевле. Пока вы работаете без длинных пауз, кэш тёплый и разговор обходится недорого. После паузы кэш остывает, и следующий запрос оплачивается полностью. Отсюда совет, который кажется странным, пока не знаешь механизма: несвязанные задачи выгоднее делать в разных сессиях, а не в одной бесконечной.

## Сессии: где хранится разговор и как откатиться

Сессия — это один разговор. Харнес записывает его на диск по мере работы, в обычный текстовый файл формата JSONL: одна строка — одна запись в JSON.

Лежит он в домашней папке, в каталоге по имени проекта:

```text
~/.claude/projects/D--PycharmProjects-My-Site-on-Astro/
├── 4e5a5be5-….jsonl          разговор: сообщения, вызовы инструментов, результаты
├── 4e5a5be5-…/
│   ├── subagents/            разговоры субагентов этой сессии
│   └── tool-results/         большие выводы инструментов, не поместившиеся в запрос
└── memory/                   авто-память проекта
```

Имя папки — это путь к проекту, в котором всё, кроме букв и цифр, заменено дефисами. Так `D:\PycharmProjects\My_Site_on_Astro` превращается в `D--PycharmProjects-My-Site-on-Astro`.

Вот как выглядит одна запись — ваше сообщение. Я оставил главные поля и разбил строку для читаемости; в файле это одна строка:

```json
{
  "type": "user",
  "uuid": "0b6f2c1e-…",
  "parentUuid": "9d41a7f3-…",
  "sessionId": "4e5a5be5-…",
  "timestamp": "2026-11-19T08:55:12.431Z",
  "cwd": "D:\\projects\\demo",
  "gitBranch": "master",
  "version": "2.1.328",
  "message": {
    "role": "user",
    "content": "сделай, чтобы сессия жила сутки"
  }
}
```

Поле `parentUuid` связывает запись с предыдущей. Благодаря этому разговор — не просто список, а дерево: когда вы откатываетесь и идёте другим путём, старая ветка остаётся в файле, а новая растёт от той же точки. Запись ответа модели устроена так же, только в `message` лежат блоки: размышление, текст, вызовы инструментов, а рядом — сведения о модели и расходе токенов.

Внутри файла записи разных типов: сообщения пользователя и ассистента, снимки файлов, смена режима, название сессии. Формат внутренний и между версиями меняется, но это обычный текст: его можно открыть, по нему можно искать. И из этого следует важное: **разговоры лежат на диске незашифрованными**. Если агент прочитал файл с паролем, пароль теперь есть и в файле сессии.

Хранятся сессии 30 дней, потом удаляются сами; срок меняется настройкой `cleanupPeriodDays`. Удалить всё, что Claude Code знает об одном проекте, можно командой `claude purge`.

Что с сессиями можно делать:

- **Продолжить.** `claude --continue` открывает последнюю сессию в этой папке, `claude --resume` показывает список. Внутри сессии то же делает `/resume`.
- **Ответвить.** `/branch` копирует разговор в новую сессию с текущего места, оригинал не меняется. Удобно попробовать другой путь.
- **Назвать.** `/rename` или флаг `--name`: по имени сессию потом проще найти.

### Откат: чекпоинты

Перед каждой правкой файла харнес сохраняет его прежнюю версию. Эти копии лежат в `~/.claude/file-history/`, по папке на сессию. Каждое ваше сообщение создаёт контрольную точку.

Команда `/rewind` (или Esc дважды на пустой строке) открывает список точек. Для выбранной можно вернуть код, вернуть разговор или и то и другое. Там же есть «сжать начиная отсюда»: файлы не трогаются, а хвост разговора заменяется пересказом.

У отката есть граница, о которой надо помнить. Он знает только про правки, сделанные инструментами `Edit` и `Write`. То, что сделала команда оболочки, он не откатит: удалённый через `rm` файл, миграцию базы, `git push`, установленный пакет. Не отслеживаются и правки субагентов, и ваши собственные правки в редакторе. Чекпоинты — это страховка внутри сессии, а не замена git.

## Папка проекта: что лежит в `.claude`

Теперь о том, чем Claude Code настраивается под конкретный проект. Почти всё живёт в папке `.claude` в корне репозитория и коммитится вместе с кодом, чтобы у всей команды агент вёл себя одинаково.

```text
проект/
├── CLAUDE.md                   инструкции проекта, читаются в каждой сессии
├── CLAUDE.local.md             личные инструкции, в git не идут
├── .mcp.json                   MCP-серверы проекта
├── .worktreeinclude            какие файлы вне git копировать в рабочие копии
└── .claude/
    ├── settings.json           настройки команды: разрешения, хуки, переменные
    ├── settings.local.json     личные настройки, в git не идут
    ├── rules/                  правила, по файлу на тему
    ├── skills/<имя>/SKILL.md   скилы
    ├── agents/                 описания субагентов
    ├── commands/               команды в старом формате
    ├── output-styles/          стили вывода
    ├── workflows/              сохранённые сценарии с несколькими агентами
    ├── agent-memory/           память субагентов
    ├── hooks/                  обычно здесь держат скрипты хуков
    └── worktrees/              отдельные рабочие копии для параллельных сессий
```

Ниже — про каждую часть: что это, когда загружается и чем отличается от соседних.

### Инструкции: `CLAUDE.md`

`CLAUDE.md` — это текстовый файл с тем, что агент должен знать в каждой сессии: как собрать проект, как запустить тесты, какие здесь есть неочевидные договорённости. Создать первую версию помогает команда `/init`.

Файлов может быть несколько, и они складываются. Порядок загрузки такой:

| Уровень | Где лежит | Для чего |
|---|---|---|
| Организация | системная папка: `C:\Program Files\ClaudeCode\`, `/etc/claude-code/`, `/Library/Application Support/ClaudeCode/` | правила компании, задаёт администратор |
| Личный | `~/.claude/CLAUDE.md` | ваши привычки во всех проектах |
| Проект | `CLAUDE.md` в корне или `.claude/CLAUDE.md` | общие правила проекта, в git |
| Личный в проекте | `CLAUDE.local.md` | ваши заметки по этому проекту, не в git |

Кроме того, читаются `CLAUDE.md` из всех папок выше рабочей. А файлы из подпапок подгружаются по требованию — когда агент читает или правит что-то в этой подпапке. В монорепозитории это позволяет держать у каждого сервиса свои инструкции и не грузить их все сразу.

Внутри можно подключать другие файлы строкой `@путь/к/файлу`. Вложенность — до четырёх уровней.

Про `AGENTS.md`. Это общий формат инструкций, который читают многие агенты. Claude Code читает его, только если в проекте нет своего `CLAUDE.md`. Поведение меняется в настройках: можно читать оба.

Главный совет про этот файл — держать его коротким. Документация называет ориентир в двести строк, и причина не в лимите, а в том, что длинные инструкции хуже соблюдаются.

### Правила: `.claude/rules/`

Правила — это те же инструкции, только разложенные по файлам, по одному на тему. Правило без шапки загружается при старте, как `CLAUDE.md`.

Интереснее правило с шапкой, где указаны маски путей:

```markdown title=".claude/rules/api-endpoints.md"
---
paths:
  - "src/api/**/*.ts"
---

# Правила для API

- Каждый эндпоинт валидирует вход.
- Ошибки отдаются в общем формате.
```

Такое правило попадёт в контекст, только когда агент прочитает или тронет подходящий файл. Так правила для базы данных не занимают место, пока идёт работа над вёрсткой.

Личные правила на все проекты кладутся в `~/.claude/rules/`.

### Авто-память

Инструкции и правила пишете вы. Авто-память агент пишет сам. Это заметки о том, что он узнал за работой и что пригодится в следующих сессиях: что вы предпочитаете, какое решение приняли, где лежит нужная панель.

Хранится она не в проекте, а в домашней папке: `~/.claude/projects/<проект>/memory/`. Внутри — индексный файл `MEMORY.md` и отдельные файлы по темам. В начале сессии в контекст попадает только начало индекса, первые двести строк. Тематические файлы агент открывает, когда они нужны.

Индекс — это просто список ссылок, по строке на заметку:

```markdown title="memory/MEMORY.md"
- [Тесты только через контейнер](tests-in-docker.md) — локальный запуск тестов падает, нужна база из docker compose
- [Панель мониторинга](grafana-dashboard.md) — где смотреть задержки API после выкладки
```

А сама заметка — файл с короткой шапкой и одним фактом:

```markdown title="memory/tests-in-docker.md"
---
name: tests-in-docker
description: Интеграционные тесты запускать только в контейнере, локально они падают
metadata:
  type: feedback
---

Интеграционные тесты запускать командой `docker compose run tests`.

**Почему:** тестам нужна база определённой версии, локально её нет.
**Как применять:** перед запуском тестов не пробовать `npm test` напрямую.
```

Типов заметок четыре: о пользователе, о его замечаниях к работе, о проекте и ссылки на внешние ресурсы. По описанию в шапке агент решает, открывать ли файл.

Что из этого следует:

- Память **локальна для машины и для вас**. Коллега её не получит, на другом компьютере её нет. Всё, что должны знать все, — в правила проекта.
- Это обычные Markdown-файлы. Их можно читать и править руками; командой `/memory` — посмотреть и выключить.
- Проект определяется по git-репозиторию, поэтому у всех рабочих копий одного репозитория память общая.
- Чистка по сроку хранения её не трогает.

Чтобы не путать, чем отличаются три вида «памяти»:

| | Кто пишет | Где лежит | Видит команда | Когда в контексте |
|---|---|---|---|---|
| `CLAUDE.md` и правила | вы | в репозитории | да | всегда или по маске путей |
| Авто-память | агент | в домашней папке | нет | индекс — всегда, темы — по требованию |
| История сессии | харнес | в домашней папке | нет | только в этой сессии |

### Скилы: знание по требованию

Скил — это папка с файлом `SKILL.md`: инструкция, как делать определённую работу. Например, как выкладывать релиз или как читать данные из аналитики. Рядом могут лежать вспомогательные файлы и скрипты.

Ключевая идея — постепенная загрузка. В спящем состоянии от скила в контексте только имя и описание. Когда задача подходит под описание, агент вызывает инструмент `Skill`, и тело файла попадает в контекст. Файлы рядом читаются, только если на них есть ссылка и они понадобились. Поэтому справочник на тысячу строк в виде скила почти ничего не стоит, а в виде правила стоил бы в каждой сессии.

```markdown title=".claude/skills/release/SKILL.md"
---
name: release
description: Выпуск новой версии. Использовать, когда просят выпустить релиз или поднять версию.
disable-model-invocation: true
allowed-tools: Bash(npm version *), Bash(git tag *)
---

1. Убедиться, что рабочее дерево чистое.
2. Поднять версию: `npm version $ARGUMENTS`.
3. Собрать проект и прогнать тесты.
```

Что здесь важно:

- `description` — это то, по чему агент решает, подходит ли скил. Описание важнее тела: плохо описанный скил не будет вызван.
- `disable-model-invocation: true` запрещает агенту запускать скил самому. Остаётся ручной вызов командой `/release 1.4.0`. Так помечают процедуры с последствиями.
- `$ARGUMENTS` заменяется на то, что вы написали после имени команды.
- `allowed-tools` заранее разрешает перечисленные инструменты на время работы скила.

Ещё скил можно запустить в отдельном контексте (`context: fork`): тогда он выполняется как субагент и возвращает только результат.

Скилы и слэш-команды — это одно и то же. Любой скил вызывается как `/имя`. Старый формат, файлы в `.claude/commands/`, по-прежнему работает. Скилы бывают личные (`~/.claude/skills/`), проектные, из плагинов и встроенные: `/code-review`, `/simplify`, `/doctor`, `/loop`, `/run` и другие.

Места в контексте под список скилов отведено немного — около одного процента окна. Когда скилов много, у редко используемых остаётся только имя. Посмотреть, сколько стоит каждый, можно в `/skills`.

### Субагенты

Субагент — это отдельный экземпляр агента со своим чистым контекстом. Главный агент даёт ему задачу, субагент работает в собственном цикле и возвращает один итоговый отчёт.

Зачем это нужно. Представьте задачу «выясни, как устроена авторизация». Чтобы ответить, надо прочитать двадцать файлов. Если их читает главный агент, все двадцать навсегда остаются в его контексте. Если читает субагент, в главный контекст возвращается одна страница выводов, а двадцать файлов исчезают вместе с субагентом.

У этого есть цена, и про неё часто забывают. Субагент не видел ваш разговор. Он знает только то, что главный агент написал ему в задании. И главный агент видит только итоговый отчёт, а не то, как субагент к нему пришёл. На каждой передаче теряются детали. Поэтому субагенты хороши для разведки и независимых кусков работы и плохи для задач, где важен весь накопленный контекст.

Встроенных субагентов несколько:

| Имя | Что делает |
|---|---|
| `Explore` | только чтение: быстрый поиск по кодовой базе |
| `Plan` | только чтение: готовит план реализации |
| `general-purpose` | все инструменты, для многошаговых задач |
| `claude-code-guide` | отвечает на вопросы о самом Claude Code |

Своих описывают файлами в `.claude/agents/` или `~/.claude/agents/`:

```markdown title=".claude/agents/test-runner.md"
---
name: test-runner
description: Запускает тесты и разбирает падения. Использовать после изменений в коде.
tools: Read, Grep, Glob, Bash
model: haiku
---

Запусти тесты, найди причину каждого падения и верни короткий список:
тест, причина, файл и строка.
```

Тело файла — это системный промпт субагента. В шапке задаётся, какие инструменты ему доступны, на какой модели он работает, в каком режиме разрешений. Простую механическую работу выгодно отдавать дешёвой модели.

Полезные возможности:

- **Фон.** Субагент может работать в фоне, пока главный агент занят другим; результат придёт уведомлением.
- **Изоляция.** С `isolation: worktree` субагент получает собственную копию репозитория и не мешает правкам в основной.
- **Форк.** Обычный субагент начинает с чистого листа. Форк наследует весь разговор; его запускает `/subtask`.
- **Своя память.** С полем `memory` у субагента появляется папка заметок, которая переживает сессии.
- **Вложенность.** Субагент может запустить своего субагента, до трёх уровней вглубь.

И про расход. Пять субагентов параллельно — это примерно пять сессий по цене. Запускать их ради задачи в три файла невыгодно.

### Хуки

Всё перечисленное выше — текст, который модель читает и обычно выполняет. Хук — это другое: ваш код, который харнес запускает сам в определённый момент, что бы модель ни решила.

Моментов, на которые можно повесить хук, больше тридцати: старт сессии, отправка сообщения, перед вызовом инструмента и после него, запрос разрешения, конец хода, сжатие контекста и так далее. Хук получает на вход JSON с описанием события и может не только что-то сделать, но и повлиять на ход: запретить вызов инструмента, добавить текст в контекст, вернуть агента к работе.

```json title=".claude/settings.json"
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "npm run lint" }]
      }
    ]
  }
}
```

Этот хук запускает линтер после каждой правки файла. Модель об этом не просили — это делает харнес.

Правило выбора такое: то, что должно происходить всегда, делается хуком, а не строчкой в инструкциях. Форматирование после правки, запрет трогать определённую папку, звук по окончании хода, запись в журнал. Подробно, со всеми событиями и рабочими примерами, — в [статье про хуки](/ru/claude-code-hooks/).

### MCP: внешние инструменты

Встроенных инструментов хватает для работы с файлами и терминалом. Но агенту бывает нужно и другое: заглянуть в трекер задач, в базу данных, в документацию библиотеки. Для этого есть MCP (Model Context Protocol) — стандарт, по которому внешняя программа-сервер объявляет свои инструменты, а агент их вызывает. Как устроен сам протокол, я писал в [отдельной статье](/ru/mcp-webmcp/).

Для Claude Code MCP-сервер — это просто ещё один набор инструментов. Подключается он командой или файлом:

```json title=".mcp.json"
{
  "mcpServers": {
    "docs": {
      "type": "http",
      "url": "https://mcp.example.com/mcp"
    },
    "local-db": {
      "command": "npx",
      "args": ["-y", "example-db-mcp"],
      "env": { "DB_URL": "${DB_URL}" }
    }
  }
}
```

Первый сервер удалённый, к нему агент ходит по HTTP. Второй локальный: Claude Code сам запускает его как процесс и общается с ним через стандартный ввод и вывод.

То же самое делается командами, без правки файла руками:

```bash
claude mcp add --transport http docs https://mcp.example.com/mcp
claude mcp add local-db -e DB_URL=postgres://localhost/app -- npx -y example-db-mcp
claude mcp add --scope project --transport http docs https://mcp.example.com/mcp
```

Первая команда добавляет удалённый сервер. Вторая — локальный: всё, что после двух дефисов, — это команда его запуска. Третья отличается флагом `--scope`: он решает, кому сервер будет виден.

Инструменты сервера получают имена вида `mcp__<сервер>__<инструмент>`, например `mcp__docs__search`. Под этими именами они фигурируют в правилах разрешений и в хуках.

Сервер можно подключить на трёх уровнях, и от уровня зависит, где хранится запись:

| Уровень | Кому виден | Где записан |
|---|---|---|
| local (по умолчанию) | вам, в этом проекте | `~/.claude.json`, в разделе проекта |
| project | всей команде | `.mcp.json` в корне репозитория |
| user | вам, во всех проектах | `~/.claude.json` |

Серверы из `.mcp.json` требуют одноразового подтверждения: чужой репозиторий не должен молча запускать программы на вашей машине.

Важная деталь про контекст. Раньше каждый сервер сразу выкладывал в контекст полные описания всех своих инструментов, и пять серверов могли съесть десятки тысяч токенов. Теперь описания отложены: в контексте только имена. Когда инструмент понадобился, агент вызывает `ToolSearch` и получает его полную схему. Поэтому много подключённых серверов больше не проблема.

И ещё одно: если вы вошли через аккаунт claude.ai, коннекторы, подключённые там (почта, календарь, диск), доступны и в Claude Code.

### Плагины, маркетплейсы и моды

Плагин — это упаковка. В одну папку собираются скилы, субагенты, хуки, MCP-серверы, стили вывода, темы, исполняемые файлы, и всё это ставится одной командой. Так делятся настройками между проектами и командами.

Источник плагинов называется маркетплейсом. Это git-репозиторий или адрес с файлом-каталогом. Официальный маркетплейс Anthropic подключается сам при первом запуске. Управление — командой `/plugin`: посмотреть доступные, поставить, включить, выключить.

Два вида плагинов стоит выделить.

**Плагины языковых серверов.** Они дают агенту инструмент `LSP`, о котором шла речь в разделе про поиск. Есть готовые для полутора десятков языков, от TypeScript и Python до Kotlin и Rust. Сам языковой сервер должен быть установлен в системе.

**Моды.** Обычный плагин добавляет агенту знания и инструменты. Мод меняет сам Claude Code: его код работает внутри программы. Мод может нарисовать панель рядом с чатом или полосу над полем ввода, добавить команду, которая выполняется мгновенно, без обращения к модели, вмешаться в вызов инструмента. Моды появились в версии 2.1.287. Написать свой можно, просто попросив агента.

К модам стоит относиться как к любой программе, которую вы запускаете: код мода работает с вашими правами и вне песочницы. Если после установки что-то сломалось, `claude --safe-mode` запустит сессию без всех настроек, плагинов и хуков.

### Стили вывода, строка состояния, клавиши

Три небольшие настройки интерфейса.

**Стиль вывода** меняет манеру ответов. Встроенные: обычный, краткий, объясняющий (добавляет пояснения, почему сделано так) и обучающий (оставляет вам куски для самостоятельной работы). Свои кладутся файлами в `output-styles/`.

**Строка состояния** — нижняя строка интерфейса. Её рисует ваш скрипт: харнес передаёт ему JSON с данными сессии, а то, что скрипт напечатает, появляется на экране. Туда выводят ветку git, модель, заполненность контекста, расход лимита.

**Клавиши** переназначаются в файле `~/.claude/keybindings.json`.

## Настройки: где лежат и кто главнее

Настройки хранятся в файлах `settings.json`. Их несколько, и одна и та же настройка может быть задана в нескольких. Побеждает уровень с более высоким приоритетом.

| Приоритет | Уровень | Файл |
|---|---|---|
| 1, высший | Организация | `managed-settings.json` в системной папке, политика ОС или настройки с сервера |
| 2 | Запуск | флаг `--settings` |
| 3 | Личные в проекте | `.claude/settings.local.json` |
| 4 | Проект | `.claude/settings.json` |
| 5 | Личные | `~/.claude/settings.json` |

Списки не перекрываются, а складываются. Правила разрешений из личного файла и из файла проекта действуют вместе.

Есть ещё один файл, который постоянно путают с настройками: `~/.claude.json`. Он лежит не в папке `.claude`, а рядом с ней, в домашнем каталоге. Это не настройки, а состояние: в какой аккаунт вы вошли, каким папкам доверяете, личные MCP-серверы, счётчики подсказок, кэши. Claude Code пишет в него сам. Руками его трогать обычно незачем.

Третий механизм — переменные окружения. Через них задают ключ API, провайдера, модель, таймауты. Их можно выставить в оболочке или в блоке `env` файла настроек.

Проверить, что на самом деле загрузилось, помогают две команды: `/status` показывает источники настроек, `/doctor` находит битые файлы и противоречия. Полный список ключей с примерами — в [справочнике](/ru/claude-code-commands-and-settings/).

## Что лежит на диске за пределами проекта

Проект — только часть картины. Большая часть данных Claude Code живёт в домашней папке пользователя. На Windows это `C:\Users\<имя>\.claude`, на macOS и Linux — `~/.claude`.

Вот что там лежит. Часть папок появляется, только когда вы начинаете пользоваться соответствующей возможностью.

```text
~/.claude/
├── settings.json          личные настройки
├── CLAUDE.md              личные инструкции на все проекты
├── keybindings.json       свои сочетания клавиш
├── rules/  skills/  agents/  commands/  output-styles/  workflows/  themes/
│                          личные правила, скилы, субагенты и прочее
├── .credentials.json      данные входа в аккаунт
├── history.jsonl          история введённых вами сообщений
├── projects/              разговоры и авто-память, по папке на проект
├── file-history/          копии файлов для отката
├── sessions/              по маленькому файлу на каждую запущенную сессию
├── session-env/           окружение сессий
├── shell-snapshots/       слепки настроек оболочки
├── paste-cache/           большие вставки из буфера
├── plans/                 планы из режима планирования
├── tasks/                 списки задач
├── plugins/               установленные плагины и маркетплейсы
├── daemon/  jobs/         состояние фоновых сессий
├── ide/                   связь с запущенными IDE
├── chrome/                мост к расширению в браузере
├── debug/                 отладочные логи
├── backups/               копии файла ~/.claude.json
├── cache/                 каталог моделей, список изменений
├── agent-memory/          память личных субагентов
└── teams/                 почтовые ящики команд агентов
```

Разберём то, что важно понимать.

**`projects/`** — самая большая и самая ценная папка. Здесь все ваши разговоры и вся авто-память. У меня в ней несколько десятков подпапок, по одной на каждый проект, где я хоть раз запускал Claude Code. Если переносите работу на другой компьютер, копировать надо её.

**`.credentials.json`** — данные входа. На Windows и Linux это файл, защищённый правами доступа к профилю пользователя. На macOS данные входа лежат в системной связке ключей, а файл используется как запасной вариант. Этот файл нельзя коммитить, пересылать и показывать.

**`history.jsonl`** — то, что вы набирали в поле ввода. Из него работают стрелка вверх и поиск по Ctrl+R. По сроку хранения не удаляется.

**`sessions/`** — служебные файлы работающих сессий: номер процесса, рабочая папка, имя, статус. По ним сессии находят друг друга и по ним же Claude Code понимает, что сессия упала.

**`file-history/`** — копии файлов перед правками. Версии называются по хэшу пути с номером: первая правка, вторая, третья.

**`shell-snapshots/`** — слепки алиасов и функций вашей оболочки. Из-за них команды агента ведут себя как ваши.

**`ide/`** — файлы-замки с портом, на котором слушает расширение в VS Code или JetBrains. Через них терминальная сессия находит открытый редактор.

Чистка работает так: разговоры, копии файлов, планы, логи и вставки удаляются, когда становятся старше срока хранения, по умолчанию 30 дней. Авто-память, история ввода и настройки не удаляются.

Теперь то, что лежит вне `~/.claude`:

| Что | Где на Windows | Где на macOS и Linux |
|---|---|---|
| Состояние и личные MCP-серверы | `C:\Users\<имя>\.claude.json` | `~/.claude.json` |
| Сама программа | `C:\Users\<имя>\.local\bin\claude.exe` | `~/.local/bin/claude` |
| Временные файлы сессии | `%TEMP%\claude\<проект>\<сессия>\` | временная папка системы |
| Настройки организации | `C:\Program Files\ClaudeCode\` | `/etc/claude-code/`, `/Library/Application Support/ClaudeCode/` |
| Мост к браузеру | `%APPDATA%\Claude Code\ChromeNativeHost` | папка настроек браузера |
| Кэш | `%LOCALAPPDATA%\claude-cli-nodejs\` | папка кэша пользователя |

Во временной папке у каждой сессии есть своя «черновая» директория. Туда агент складывает одноразовые скрипты и промежуточные файлы, чтобы не мусорить в проекте.

Всё, что хранится в `~/.claude`, можно перенести в другое место переменной `CLAUDE_CONFIG_DIR`. Это же способ держать на одной машине два аккаунта: у каждого своя папка конфигурации.

## Разрешения: что агенту можно без спроса

До сих пор речь шла о том, что агент умеет. Теперь — о том, что ему разрешено. Это отдельный слой, и работает он в харнесе: модель может попросить что угодно, но выполнит харнес только разрешённое.

### Режимы

Режим определяет поведение по умолчанию. Переключается сочетанием Shift+Tab прямо во время работы.

| Режим | Что делает без вопросов |
|---|---|
| Ручной (`default`) | только читает; на правки и команды спрашивает |
| `acceptEdits` | плюс правит файлы и выполняет простые файловые команды в рабочей папке |
| `plan` | читает и исследует, пишет план; исходники не трогает |
| `auto` | всё, но каждое действие проверяет фоновый классификатор |
| `dontAsk` | то, что разрешено правилами; всё остальное молча отклоняет |
| `bypassPermissions` | всё без вопросов; правила запрета остаются в силе |

Последний режим включается флагом `--dangerously-skip-permissions`, и название честное: он предназначен для изолированных сред — контейнера или виртуальной машины без доступа к чему-либо ценному.

### Правила

Поверх режима действуют правила трёх видов: разрешить, спросить, запретить.

```json title=".claude/settings.json"
{
  "permissions": {
    "allow": ["Bash(npm run *)", "Edit(src/**)"],
    "ask": ["Bash(git push *)"],
    "deny": ["Read(./.env)", "Read(./secrets/**)"]
  }
}
```

Правило — это имя инструмента и уточнение в скобках. Для команд это начало команды со звёздочкой, для файлов — маска пути, для веба — домен.

Примеры правил и того, что они значат:

| Правило | Что покрывает |
|---|---|
| `Bash(npm run build)` | ровно эту команду |
| `Bash(npm run *)` | любую команду, начинающуюся с `npm run` |
| `Bash(git log *)` | `git log` с любыми аргументами, но не `git push` |
| `Edit(src/**)` | правку любых файлов внутри `src` |
| `Read(./.env)` | чтение файла `.env` в корне проекта |
| `Read(~/.ssh/**)` | чтение чего угодно в папке ключей |
| `WebFetch(domain:docs.example.com)` | загрузку страниц с этого домена |
| `mcp__docs__*` | все инструменты MCP-сервера `docs` |
| `Agent(Explore)` | запуск субагента `Explore` |
| `Bash` | инструмент целиком |

Как это работает на живом примере. Агент хочет выполнить `npm run test && git push origin main`. Харнес делит команду на две части. Первая подходит под разрешение `Bash(npm run *)`. Вторая подходит под правило «спросить» `Bash(git push *)`. Итог: вопрос вам, и в вопросе видна вся команда целиком.

Когда вы в диалоге выбираете «больше не спрашивать», харнес сам дописывает правило в личные настройки проекта, `.claude/settings.local.json`. Посмотреть и почистить накопившееся можно командой `/permissions`.

Проверяются правила в порядке: сначала запреты, потом «спросить», потом разрешения. Побеждает первое совпадение, поэтому запрет всегда сильнее разрешения. Запрет на чтение файла работает и для поиска: такой файл выпадает из результатов.

Несколько вещей, которые делают правила надёжнее, чем кажется:

- Составная команда разбирается на части. `npm test && rm -rf build` проверяется как две команды, и разрешены должны быть обе.
- Обёртки вроде `timeout` или `nohup` отбрасываются перед проверкой.
- Перенаправление вывода в файл проверяется как правка этого файла.

И одна вещь, из-за которой на правила для команд нельзя полагаться как на стену: одно и то же можно выполнить многими способами. Запрет `Bash(curl *)` не поймает `/usr/bin/curl` или скрипт на Python, который делает тот же запрос. Запреты на команды защищают от случайностей, а не от целенаправленного обхода. Настоящую границу ставит песочница.

### Доверие папке и защищённые пути

При первом запуске в новой папке Claude Code спрашивает, доверяете ли вы ей. Это не формальность. Файлы проекта могут содержать хуки и MCP-серверы, то есть код, который выполнится на вашей машине. До подтверждения разрешающие правила из проекта не применяются. Чужой репозиторий стоит сначала посмотреть глазами.

Кроме того, есть защищённые пути, запись в которые требует подтверждения даже в режиме автоматических правок: папки `.git`, `.vscode`, `.idea`, `.claude`, файлы настроек оболочки, `.mcp.json`. Изменив их, можно заставить выполниться произвольный код, поэтому харнес бережёт их отдельно.

### Авто-режим

Ручной режим безопасен, но утомителен: на сотом подтверждении человек перестаёт читать, что подтверждает. Авто-режим решает это иначе. Вопросов нет, но каждое действие, которое не разрешено правилами явно, проверяет отдельная модель-классификатор.

Что она видит: ваши сообщения, вызовы инструментов и инструкции проекта. Результаты инструментов ей не показывают — чтобы текст из прочитанного файла или веб-страницы не мог уговорить и её тоже.

Что она блокирует по умолчанию: скачать и сразу выполнить скрипт из сети, отправить секреты наружу, выкатить в продакшен, удалить данные в облаке, выдать права доступа, сделать `git push --force` или `git reset --hard`. Что пропускает: работу с файлами в проекте, установку объявленных зависимостей, запросы на чтение, обычный push в ветку.

Если классификатор заблокировал три действия подряд, авто-режим приостанавливается и возвращаются обычные вопросы.

Свои правила для классификатора пишутся обычным текстом в личных настройках: какие репозитории и сервисы считать своими, что запрещено всегда.

```json title="~/.claude/settings.json"
{
  "autoMode": {
    "environment": [
      "$defaults",
      "Репозитории организации example-org на GitHub — свои",
      "Бакет example-staging — тестовый, писать в него можно"
    ],
    "hard_deny": [
      "$defaults",
      "Любые изменения в продакшен-базе данных"
    ]
  }
}
```

Это не шаблоны, а предложения на человеческом языке: их читает модель-классификатор. Строка `"$defaults"` сохраняет встроенные правила, без неё ваш список заменил бы их. Из настроек проекта этот блок не читается — иначе чужой репозиторий мог бы разрешить себе что угодно.

И главное, что надо понимать: авто-режим экономит подтверждения, но границей безопасности его не считает сама Anthropic. Это внимательный наблюдатель, а не стена.

## Песочница и изоляция

Разрешения решают, что агент *попросит* сделать. Изоляция решает, что он *сможет* сделать, даже если что-то пошло не так. Вариантов несколько, от лёгкого к строгому.

### Песочница для команд

Песочница — это ограничение на уровне операционной системы для команд, которые запускает агент. Команда и все процессы, которые она породит, получают урезанный доступ:

- **Запись** — только в рабочую папку и временную директорию.
- **Сеть** — прямого выхода нет. Весь трафик идёт через локальный прокси, который пропускает только разрешённые домены.
- **Чтение** — по умолчанию почти весь диск. Папки с ключами надо закрывать явно.

```json title=".claude/settings.json"
{
  "sandbox": {
    "enabled": true,
    "network": {
      "allowedDomains": ["registry.npmjs.org", "*.githubusercontent.com"]
    },
    "filesystem": {
      "denyRead": ["~/.ssh", "~/.aws"]
    }
  }
}
```

На macOS песочница построена на системном механизме Seatbelt, на Linux и в WSL2 — на bubblewrap. **На Windows без WSL песочницы нет**: команды выполняются как обычно. Если она вам нужна на Windows, запускайте Claude Code внутри WSL2.

По умолчанию песочница выключена; включается командой `/sandbox`. У неё приятный побочный эффект: раз команда не может ничего испортить за пределами проекта, её можно выполнять без вопроса. Подтверждений становится заметно меньше.

Чего песочница не покрывает, и это надо знать. Она оборачивает только команды оболочки. Инструменты чтения и правки файлов работают вне её и подчиняются правилам разрешений. Локальные MCP-серверы, хуки и моды тоже запускаются вне песочницы, с вашими правами.

### Отдельные рабочие копии

Вторая задача изоляции — чтобы параллельные сессии не мешали друг другу. Если два агента правят одни и те же файлы в одной папке, получится каша.

Решение — git worktree. Это штатная возможность git: вторая рабочая папка того же репозитория на своей ветке. История общая, файлы раздельные.

```bash
claude --worktree feature-auth
```

Команда создаёт рабочую копию в `.claude/worktrees/feature-auth/` на новой ветке и запускает сессию в ней. Фоновые сессии и субагенты с изоляцией делают то же автоматически. Копия без изменений удаляется при выходе сама.

Одна практическая деталь: файлы, которых нет в git, в новую копию не попадают. Если проекту нужен `.env`, перечислите его в файле `.worktreeinclude`, и он будет скопирован.

Важно не путать: worktree защищает ваши файлы от других агентов, а не машину от агента. Это изоляция работы, а не безопасность.

### Контейнер и виртуальная машина

Самая надёжная изоляция — запустить агента там, где нечего портить.

**Dev-контейнер.** У Anthropic есть готовая конфигурация: контейнер с Claude Code и сетевым экраном, который пропускает только нужные адреса. Внутри можно включить режим без вопросов, потому что агенту доступен только смонтированный проект.

**Виртуальная машина.** То же, но граница ещё жёстче. Об этом варианте подробно ниже, в разделе про удалённую работу.

**Облачная сессия.** Anthropic запускает агента на своей виртуальной машине. Ваш компьютер не участвует вовсе.

Сводка, чтобы выбирать:

| Способ | От чего защищает | Чего не закрывает |
|---|---|---|
| Правила разрешений | от случайных действий | обходятся другим способом сделать то же |
| Авто-режим | от явно опасных действий без вопросов | не является границей безопасности |
| Песочница | команды не выйдут за проект и разрешённые домены | инструменты файлов, MCP, хуки; нет на Windows без WSL |
| Worktree | сессии не мешают друг другу | не защищает машину |
| Контейнер, ВМ | агент не видит вашу систему | то, что вы сами туда смонтировали и какие ключи дали |

## Модели, усилие и размышление

Харнес один, а моделей за ним несколько, и у каждой есть ручки.

**Модель** выбирается командой `/model` или флагом `--model`. Обычно пишут не полный идентификатор, а короткое имя семейства: `fable`, `opus`, `sonnet`, `haiku`. За коротким именем всегда стоит самая свежая модель семейства. Старшие модели умнее и дороже, младшие быстрее и дешевле. Есть и составной вариант `opusplan`: старшая модель планирует, средняя исполняет.

**Усилие** (effort) — это то, сколько модель думает и проверяет, прежде чем ответить. Уровней пять: `low`, `medium`, `high`, `xhigh`, `max`. Низкий годится для мелких понятных правок, высокий — когда важна проверка, максимальный — для по-настоящему трудных задач, с убывающей отдачей. Задаётся командой `/effort`. Усилие влияет и на скорость, и на расход: на `max` та же задача может стоить в разы больше, чем на `medium`.

**Размышление** (thinking) — это рассуждения модели перед ответом, которые вы видите свёрнутыми. У нынешних моделей оно адаптивное: модель сама решает, где подумать подольше. Слово `ultrathink` в сообщении поднимает усилие на один этот ход.

**Быстрый режим** (`/fast`) — та же модель, но ответ идёт примерно в два с половиной раза быстрее и стоит дороже. Только для старших моделей.

**Советник** (`/advisor`) — вторая, более сильная модель, с которой основная сверяется в ключевые моменты задачи. Экспериментальная возможность.

**Запасная модель** — если основная перегружена, сессия продолжит на запасной. Задаётся флагом `--fallback-model`.

Отдельно стоит **ultracode**. Это не уровень усилия, а режим работы: на каждую существенную задачу агент сам пишет сценарий с несколькими субагентами и запускает его. О сценариях — в разделе про взаимодействие сессий. Расход токенов в этом режиме заметно выше.

Одна и та же ручка есть и у частей системы. Субагенту и скилу можно назначить свою модель и своё усилие в шапке файла. Так разведку отдают быстрой дешёвой модели, а главный разговор оставляют сильной.

## Где запускается Claude Code

Харнес — это один и тот же движок, у которого несколько лицевых сторон.

| Где | Что это | Особенности |
|---|---|---|
| Терминал | программа `claude` | полный набор возможностей, отсюда всё началось |
| VS Code | расширение | правки показываются в окне редактора, агент видит выделенный код |
| JetBrains | плагин | просмотр правок в IDE, общий с терминалом сеанс |
| Приложение Desktop | программа для macOS и Windows | несколько сессий рядом, просмотр диффов, встроенный браузер, подключение по SSH |
| Веб | claude.ai/code | облачные сессии, работают без вашего компьютера |
| Телефон | приложение Claude | облачные сессии и управление сессиями на компьютере |
| Slack | `@Claude` в канале | задача из переписки уходит в облачную сессию |
| CI | GitHub Actions, GitLab CI/CD | запуск по событию, без человека |

Локальные поверхности делят между собой всё: настройки, инструкции проекта, MCP-серверы, историю сессий. Разговор, начатый в терминале, можно открыть в приложении командой `/desktop`. Облачные сессии живут отдельно: у них своё окружение, и до файлов на вашем диске они не дотягиваются.

Установка. Основной способ — собственный установщик: одна команда для macOS и Linux, одна для PowerShell. Есть пакеты для Homebrew, WinGet и npm. Поддерживаются macOS 13 и новее, Windows 10 и новее, распространённые дистрибутивы Linux; нужно от 4 ГБ памяти. Установленная так программа обновляется сама, в фоне. Канал обновлений выбирается: самый свежий или стабильный, с задержкой около недели.

На Windows два варианта. Запуск напрямую: всё работает, кроме песочницы; желательно поставить Git for Windows, чтобы у агента был Bash. Запуск в WSL2: это полноценный Linux со всеми возможностями, включая песочницу, но без интеграции с браузером Chrome.

## Браузер: какие есть варианты

Агенту часто нужно посмотреть на результат своей работы: открыть страницу, нажать кнопку, прочитать ошибку в консоли. Способов много, и выбирать между ними проще по трём вопросам.

**Чей это браузер.** Ваш настоящий, со всеми входами в почту и рабочие сервисы, или отдельный чистый, где агент ни к чему вашему не дотянется.

**Как агент видит страницу.** Тут три способа, и от них зависят точность и расход токенов:

- *Снимок экрана.* Картинка, как её видит человек. Универсально, но дорого по токенам, и попадать по кнопке приходится по координатам.
- *Дерево доступности.* Это структурное описание страницы, которым пользуются программы чтения с экрана: «кнопка „Войти“, поле „Почта“, ссылка „Забыли пароль“». Агент получает его текстом, где у каждого элемента есть короткий номер, и нажимает по номеру, а не по координатам. Дешевле и точнее картинки.
- *Внутренности браузера.* Консоль, сетевые запросы, стили, замеры скорости — то, что вы видите в инструментах разработчика.

**Нужно ли окно.** На ноутбуке окно есть. В контейнере, на сервере и в CI его нет, и браузер должен работать в режиме без интерфейса (headless).

Сводка всех вариантов:

| Вариант | Чей браузер | Как видит страницу | Без окна | Кто делает |
|---|---|---|---|---|
| `WebFetch`, `WebSearch` | никакой | текст в пересказе | да | встроено |
| Claude in Chrome | ваш, с входами | страница, снимки, консоль, сеть | нет | Anthropic |
| Встроенный браузер Desktop | чистый, в приложении | страница и снимки | нет | Anthropic |
| Playwright MCP | свой профиль или ваш браузер | дерево доступности, по желанию снимки | да | Microsoft |
| Playwright CLI | чистый по умолчанию | дерево доступности, по запросу | да, по умолчанию | Microsoft |
| Chrome DevTools MCP | свой или уже запущенный Chrome | дерево, снимки, консоль, сеть, замеры скорости | да | команда Chrome DevTools |
| Firefox DevTools MCP | отдельный профиль Firefox | дерево и снимки | да | Mozilla |
| Свой скрипт на Playwright или Puppeteer | любой | что напишете в скрипте | да | вы и агент |
| Облачный браузер | на серверах сервиса | зависит от сервиса | да | сторонние платные сервисы |
| Управление компьютером | любой, как окно на экране | снимок экрана | нет | Anthropic |

Теперь по порядку.

### Встроенные инструменты

`WebFetch` и `WebSearch` — это не браузер. Они годятся, чтобы прочитать публичную страницу документации, и не годятся для всего, где нужен вход, JavaScript или нажатие кнопок. Они описаны выше, в разделе про инструменты.

### Claude in Chrome: ваш настоящий браузер

Это расширение для Chrome и Edge плюс мост к Claude Code. Включается флагом `claude --chrome` или командой `/chrome`. Агент работает в настоящем окне вашего браузера, в новой вкладке, и видит сайты так, как их видите вы: с вашими входами в почту, панели управления, трекеры.

Что он умеет: переходить по страницам, нажимать и заполнять формы, читать текст страницы, консоль и сетевые запросы, делать снимки экрана, записывать GIF с ходом действий.

Это и сила, и риск. Сила в том, что агент может сделать что-то в сервисе, где у вас уже открыт сеанс, не получая паролей. Риск в том же самом. Поэтому доступ выдаётся в расширении по каждому сайту отдельно, а на входе в аккаунт и на капче агент останавливается и ждёт вас.

Как устроена связь. Расширение не может само общаться с программой на компьютере, поэтому Claude Code при первом включении регистрирует в системе небольшой посредник (native messaging host). Через него расширение и терминальная сессия обмениваются командами. У меня он лежит в `%APPDATA%\Claude Code\ChromeNativeHost`.

Ограничения: нужна подписка и вход через аккаунт, с ключом API не работает; в WSL не работает; режима без окна нет; открытое на странице системное окно с вопросом блокирует управление.

### Встроенный браузер приложения Desktop

В приложении Desktop есть панель браузера рядом с чатом. Профиль у неё свой, чистый, ваших входов там нет. Она показывает запущенное приложение проекта и внешние сайты, и агент может в ней действовать. Действия на внешних сайтах требуют подтверждения.

Для разработки это спокойнее, чем расширение: агент видит ваш сайт на локальном сервере, а к вашей почте доступа не имеет.

### Playwright MCP

Playwright — это библиотека Microsoft для автоматизации браузеров; на ней пишут сквозные тесты. У неё есть MCP-сервер, который даёт агенту инструменты управления браузером: открыть адрес, нажать, ввести текст, сделать снимок.

Подключается одной командой:

```bash
claude mcp add playwright npx @playwright/mcp@latest
```

Или плагином из официального маркетплейса, который делает то же самое:

```bash
claude plugin install playwright@claude-plugins-official
```

Главная особенность — по умолчанию агент работает с деревом доступности, а не с картинкой. Он запрашивает снимок страницы и получает текст примерно такого вида:

```yaml
- heading "Вход" [level=1]
- textbox "Почта" [ref=e12]
- textbox "Пароль" [ref=e13]
- button "Войти" [ref=e15]
- link "Забыли пароль?" [ref=e16]
```

Дальше он говорит «нажми `e15`», и сервер нажимает именно эту кнопку. Модели не нужно угадывать координаты, и токенов уходит заметно меньше, чем на картинку. Режим с координатами тоже есть: он включается флагом `--caps=vision` и нужен там, где дерево не помогает, например на холсте с графикой.

Что настраивается флагами:

| Флаг | Что делает |
|---|---|
| `--browser` | какой браузер: Chrome, Edge, Firefox или WebKit |
| `--headless` | работать без окна; по умолчанию окно показывается |
| `--isolated` | профиль только в памяти, после закрытия ничего не остаётся |
| `--user-data-dir` | свой путь к профилю |
| `--storage-state` | загрузить сохранённые куки в изолированную сессию |
| `--extension` | подключиться к вашему уже открытому Chrome или Edge через расширение Playwright |
| `--cdp-endpoint` | подключиться к браузеру, запущенному с отладочным портом |

Про профиль стоит понимать одно. По умолчанию он постоянный: сервер заводит собственную папку профиля и хранит в ней входы между запусками. Это не ваш личный профиль, но если вы один раз вошли в сервис в этом окне, вход сохранится. Для тестов, где нужна чистота, ставят `--isolated`.

Сами авторы предупреждают о двух вещах. Сервер не является границей безопасности: списки разрешённых адресов не покрывают перенаправления. И среди инструментов есть выполнение произвольного кода в браузере, что равносильно полному доступу к странице.

### Playwright CLI

У того же Playwright есть второй способ, сделанный специально для агентов в терминале: обычная программа командной строки вместо MCP-сервера.

```bash
npm install -g @playwright/cli@latest
playwright-cli install --skills
```

Вторая команда ставит скилы для Claude Code: из них агент узнаёт, какие команды есть и как ими пользоваться. Дальше он просто вызывает программу через `Bash`:

```bash
playwright-cli open https://example.com
playwright-cli snapshot --depth=3
playwright-cli click e15
```

В чём разница с MCP-сервером. MCP-сервер возвращает дерево страницы после каждого действия, и оно оседает в контексте. Программа командной строки печатает только то, что запросили: снимок нужной глубины, результат поиска элемента. Авторы Playwright сами пишут, что для агентов-программистов такой путь экономнее, а MCP-сервер лучше там, где нужно долго исследовать страницу с сохранением состояния.

По умолчанию браузер здесь запускается без окна и с чистым профилем в памяти; окно включается флагом `--headed`, сохранение профиля — флагом `--persistent`.

### Chrome DevTools MCP

Этот сервер делает команда инструментов разработчика Chrome. Нажимать и вводить текст он тоже умеет, но его смысл в другом: он открывает агенту то, что вы видите в панели разработчика.

- **Скорость.** Записать трассировку загрузки страницы и разобрать, что её тормозит.
- **Сеть.** Список запросов, заголовки и тела ответов.
- **Консоль.** Сообщения и ошибки со стеком, приведённым к исходникам.
- **Стили.** Какие правила CSS реально применились к элементу.
- **Аудит.** Проверка Lighthouse.
- **Память.** Снимки кучи для поиска утечек.

Ставится плагином:

```bash
claude plugin marketplace add ChromeDevTools/chrome-devtools-mcp
claude plugin install chrome-devtools-mcp@chrome-devtools-plugins
```

Он может запустить собственный Chrome, а может подключиться к уже работающему. Для этого Chrome запускают с отладочным портом и отдельной папкой профиля, а серверу передают адрес:

```bash
chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug
npx -y chrome-devtools-mcp@latest --browser-url http://127.0.0.1:9222
```

Выбор между ним и Playwright простой. «Пройди по форме и проверь, что заказ создаётся» — это Playwright. «Страница грузится четыре секунды, выясни почему» — это Chrome DevTools. Работает он только с Chrome. И по умолчанию отправляет Google статистику использования; она отключается флагом `--no-usage-statistics`.

### Firefox DevTools MCP

У Mozilla есть свой официальный сервер, пока в ранней версии:

```bash
claude mcp add firefox-devtools npx @mozilla/firefox-devtools-mcp@latest
```

Устроен он похоже: снимок страницы с номерами элементов, нажатие и ввод по номеру, снимки экрана, режим без окна. Нужен, когда ошибка воспроизводится именно в Firefox. Авторы советуют заводить для него отдельный профиль и не подключать основной.

Для Safari отдельного сервера я не нашёл. Движок WebKit, на котором он построен, доступен через Playwright: флаг `--browser webkit`.

### Свой скрипт

Самый простой способ часто забывают: никаких серверов, агент пишет обычный скрипт на Playwright или Puppeteer и запускает его через `Bash`.

```javascript title="check-login.mjs"
import { chromium } from 'playwright';

const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('http://localhost:3000/login');
await page.getByLabel('Почта').fill('user@example.com');
await page.getByRole('button', { name: 'Войти' }).click();
console.log(await page.getByRole('alert').textContent());
await page.screenshot({ path: 'login.png' });
await browser.close();
```

Агент запускает скрипт, читает напечатанный текст, а снимок открывает инструментом `Read` и смотрит на него как на картинку.

У этого способа три достоинства. В контекст попадает только то, что скрипт напечатал. Скрипт остаётся в репозитории и превращается в тест. И он одинаково работает на ноутбуке, в контейнере и в CI. Недостаток один: это не диалог со страницей. Каждое «а что там теперь» — новый запуск.

Если в проекте уже есть сквозные тесты, это и есть лучший способ проверки: агент дописывает тест и запускает его. На этом же построены встроенные скилы `/run` и `/verify`: они сами определяют тип проекта, запускают приложение и смотрят на результат, а `/run-skill-generator` записывает найденный рецепт запуска в скил проекта.

### Облачные браузеры и сервисы сбора данных

Отдельный класс — сервисы, где браузер работает на чужих серверах, а агент управляет им через MCP. Все они сторонние и платные или с ограниченным бесплатным тарифом.

| Сервис | Для чего |
|---|---|
| Browserbase | браузеры в облаке; управление описанием действия словами |
| browser-use | управляет вашим локальным Chrome или облачным браузером сервиса |
| Firecrawl | не управление, а сбор: страница или целый сайт превращаются в Markdown |
| Bright Data | сбор данных и браузер с обходом защиты от роботов |

Они нужны там, где локального браузера мало: сотни страниц параллельно, сайты с защитой от автоматизации, другая страна в адресе. Для проверки собственного приложения они не нужны. И помните, что страницы и введённые данные при этом проходят через серверы третьей стороны.

### Как выбрать

- **Проверить свой сайт на локальном сервере** — встроенный браузер Desktop или Playwright; в проекте с тестами — свой скрипт.
- **Сделать что-то в сервисе, где вы уже вошли** — Claude in Chrome. Или Playwright с флагом `--extension`.
- **Найти, почему страница медленная или что падает в консоли** — Chrome DevTools MCP.
- **Работа на сервере, в контейнере, в CI** — Playwright CLI, Playwright MCP с `--headless` или свой скрипт. Расширение для Chrome там не работает.
- **Ошибка только в одном браузере** — Playwright с нужным `--browser` или сервер Mozilla.
- **Массовый сбор данных** — облачные сервисы.

Два предостережения для всех вариантов сразу. Содержимое страницы — это чужой текст, и в нём могут быть инструкции, адресованные агенту; чем больше у браузера ваших входов, тем дороже ошибка. И каждый MCP-сервер браузера запускается вне песочницы, с вашими правами.

## Настольные и мобильные приложения

С браузером понятно. А что, если нужная программа — не сайт? Настольное приложение, редактор макетов, среда разработки, симулятор телефона. Способов дотянуться до них тоже несколько, и общий принцип тот же, что с браузером: чем уже и точнее инструмент, тем лучше. Смотреть на экран и двигать мышь — последнее средство.

Сам Claude Code перебирает варианты в таком порядке: готовый коннектор или MCP-сервер программы → команда в терминале → браузер → панель симулятора → управление экраном. Разберём их в этом же порядке.

### Не трогать окно: файлы и командная строка

Самый надёжный способ работать с программой — не открывать её вовсе.

**Файлы.** Документ Word, таблица Excel, презентация — это файлы известных форматов. Агент читает и создаёт их библиотеками, небольшим скриптом, и для этого есть готовые скилы. Приложение Office при этом не запускается.

**Командная строка.** У многих настольных программ есть режим без окна. Blender рендерит сцену из командной строки, Android Studio собирает проект через Gradle, Xcode — через `xcodebuild`, Docker Desktop управляется командой `docker`. Агенту достаточно инструмента `Bash`.

### Скриптовые интерфейсы операционной системы

Следующий уровень — программа запущена, но управляют ею не мышью, а через программный интерфейс, который предусмотрела система. До них агент дотягивается обычными командами оболочки.

| Система | Интерфейс | Что умеет |
|---|---|---|
| Windows | PowerShell и COM | управлять приложениями Office как объектами: открыть книгу, заполнить ячейки, сохранить |
| Windows | UI Automation | читать дерево элементов любого окна и нажимать их; это интерфейс для программ чтения с экрана |
| macOS | AppleScript, JXA | посылать команды приложениям, которые поддерживают сценарии: Finder, Почта, Safari, Заметки |
| Linux | xdotool, ydotool | имитировать клавиатуру и мышь, двигать окна |

Пример для Windows. Так агент записывает значение в открытую таблицу Excel, не видя её окна:

```powershell
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $true
$book = $excel.Workbooks.Open("C:\reports\sales.xlsx")
$book.Sheets.Item(1).Range("B2").Value2 = 1250
$book.Save()
$excel.Quit()
```

А так на macOS он просит Finder показать папку:

```bash
osascript -e 'tell application "Finder" to open folder "Documents" of home'
```

Отличие от управления мышью принципиальное. Команда «запиши 1250 в ячейку B2» либо выполнилась, либо вернула ошибку. Ей не мешает ни разрешение экрана, ни всплывшее поверх окно, ни сменившаяся тема оформления.

На macOS такие сценарии требуют разрешений в системных настройках: «Автоматизация» для команд приложениям и «Универсальный доступ» для управления интерфейсом. На Linux `xdotool` работает только под X11, для Wayland нужен `ydotool`.

### MCP-серверы программ

Многие программы теперь сами дают агентам официальный вход — MCP-сервер. Это самый удобный путь: программа объявляет понятные инструменты, а не заставляет угадывать, куда нажать.

| Программа | Сервер | Что даёт |
|---|---|---|
| Figma | официальный, от Figma | контекст макета, переменные, снимки, запись на холст |
| IDE от JetBrains | встроен в IDE с версии 2025.2 | сборка, ошибки в файле, запуск конфигураций, поиск и рефакторинг |
| Xcode | официальный плагин от Apple | сборка и тесты, предпросмотр SwiftUI, симуляторы, логи сборки |
| Unity | официальный плагин и серверы сообщества | сцены, объекты, скрипты, тесты |
| Blender | от сообщества | выполнение Python внутри Blender, рендер сцены |
| Симулятор iOS, Android | от сообщества | дерево элементов экрана, нажатия, снимки |

Подключается такой сервер как любой другой. Например, Figma:

```bash
claude mcp add --transport http figma https://mcp.figma.com/mcp
```

С IDE отдельная история: помимо MCP-сервера у JetBrains и VS Code есть собственная интеграция с Claude Code. Через неё агент видит открытый файл, выделенный фрагмент и ошибки, которые показывает редактор, а правки появляются в окне сравнения.

Есть и серверы общего назначения, которые открывают агенту весь рабочий стол: для Windows — сервер от сообщества, который читает дерево элементов окон через UI Automation, нажимает, печатает и запускает PowerShell; для macOS — сервер, который выполняет сценарии AppleScript. Это мощно и поэтому опасно: по сути, полный доступ к системе. Сами авторы об этом предупреждают. К серверам от сообщества стоит относиться как к любой чужой программе с такими правами: посмотреть код, посмотреть, что он отправляет наружу.

### Приложения на Electron

Многие настольные программы — Slack, VS Code, Discord, Notion — написаны на Electron. Внутри это браузер Chromium, и к нему применимо всё из раздела про браузеры.

Если это ваше собственное приложение, у Playwright есть поддержка Electron, пока экспериментальная: скрипт запускает приложение, получает его окна и работает с ними как со страницами.

```javascript title="check-app.mjs"
import { _electron as electron } from 'playwright';

const app = await electron.launch({ args: ['main.js'] });
const window = await app.firstWindow();
await window.getByRole('button', { name: 'Новый документ' }).click();
await window.screenshot({ path: 'app.png' });
await app.close();
```

Второй путь — запустить приложение с отладочным портом, флагом `--remote-debugging-port`, и подключить к этому порту Chrome DevTools MCP так же, как к обычному Chrome.

### Мобильные приложения

**iOS.** В приложении Desktop на macOS есть панель симулятора iOS. Агент собирает приложение, ставит его в симулятор, нажимает, вводит текст и делает снимки. Управление экраном для этого не используется: панель работает через штатные средства Apple, поэтому системные разрешения на запись экрана не нужны. Работает только с симулятором, не с настоящим телефоном.

Из терминала то же делается командой `xcrun simctl` и MCP-серверами для симулятора.

**Android.** Здесь всё держится на `adb`, штатной утилите Android. Через неё агент ставит сборку на эмулятор или подключённый телефон, запускает экран, читает логи, делает снимок, нажимает по координатам:

```bash
adb install -r app/build/outputs/apk/debug/app-debug.apk
adb shell am start -n com.example.app/.MainActivity
adb logcat -d -t 200
adb exec-out screencap -p > screen.png
```

Есть и MCP-серверы для мобильных устройств, которые вместо координат дают дерево элементов экрана — так же, как Playwright для страниц.

### Управление компьютером: когда остальное не подошло

Управление компьютером (computer use) — это когда агент работает с машиной как человек: смотрит на снимок экрана, двигает мышь, нажимает клавиши. Так можно дотянуться до того, у чего нет ни командной строки, ни программного интерфейса: старая корпоративная программа, панель управления оборудованием, проприетарный инструмент.

Где это доступно. В приложении Desktop — на macOS и на Windows. В терминале — только на macOS, включается через `/mcp`. Возможность помечена как предварительная и требует личной подписки.

Как это устроено с точки зрения безопасности:

- Доступ выдаётся по приложениям. Агент просит разрешение на конкретную программу, и вы его даёте на сессию.
- У приложений разные уровни. Браузеры — только смотреть. Терминалы и редакторы кода — смотреть и кликать, но не печатать: иначе это был бы полный доступ к оболочке в обход всех правил. Остальное — полное управление.
- Работать может только одна сессия одновременно. Остальные программы на время хода скрываются, а терминал с самим Claude Code в снимки не попадает.
- Esc прерывает работу из любого места.

Почему это последнее средство. Оно самое медленное: каждое действие — снимок экрана и запрос к модели. Самое хрупкое: сдвинулась кнопка — агент промахнулся. И песочницы тут нет: агент действует на настоящем рабочем столе, с вашими правами, а содержимое экрана — ещё один канал, через который в него может попасть чужой текст с инструкциями.

Рядом стоит Dispatch — возможность дать задачу с телефона приложению Desktop на вашем компьютере. Оно само запускает сессию, а вам приходит уведомление, когда работа закончена или нужно подтверждение.

### Как выбрать

| Что нужно | Чем делать |
|---|---|
| Создать или изменить документ, таблицу, презентацию | работа с файлом, без запуска программы |
| Собрать, запустить, отрендерить | командная строка программы |
| Управлять приложением Office на Windows | PowerShell и COM |
| Команды приложениям на macOS | AppleScript |
| Макеты, IDE, игровой движок, 3D-редактор | MCP-сервер этой программы |
| Своё приложение на Electron | Playwright |
| Приложение для iOS | панель симулятора в Desktop или `xcrun simctl` |
| Приложение для Android | `adb` |
| Программа без какого-либо программного входа | управление компьютером |

## Работа без человека

Всё, что описано выше, — про интерактивный режим, где вы сидите рядом. Но тот же движок запускается и без интерфейса.

```bash
claude -p "Найди в логах причину падения и опиши её одним абзацем" --output-format json
```

Флаг `-p` означает: выполнить задачу, напечатать результат и выйти. Вывод бывает трёх видов: обычный текст, один JSON с результатом, стоимостью и идентификатором сессии, или поток JSON-событий по мере работы. Можно задать схему, и тогда ответ придёт в строго заданной структуре.

Что важно в этом режиме:

- **Спрашивать некого.** Всё, что потребовало бы подтверждения, отклоняется. Нужные действия разрешают заранее: флагом `--allowedTools` или режимом разрешений.
- **Окно доверия папке не показывается.** Поэтому запускать так стоит только в папках, которым вы доверяете.
- **Есть ограничитель бюджета**: `--max-budget-usd` остановит работу, когда потрачена заданная сумма.
- **Есть «голый» режим** `--bare`: без хуков, плагинов, памяти и автоматического чтения инструкций. Он даёт предсказуемый результат в скриптах, где окружение машины не должно влиять на ответ.

На этом режиме построены готовые интеграции: действие для GitHub Actions и шаблон для GitLab CI, которые запускают агента на событие в репозитории — новый запрос на слияние, упавшая сборка, упоминание в комментарии.

А если нужно встроить агента в свою программу, есть **Agent SDK** для Python и TypeScript. Это тот же цикл, те же инструменты и та же работа с контекстом, только в виде библиотеки: вы вызываете функцию и получаете поток событий.

## Фоновые сессии

Интерактивная сессия занимает терминал. Если задача на час, а смотреть на неё незачем, сессию можно увести в фон.

```bash
claude --bg "Обнови зависимости и почини то, что сломается"
claude agents
```

Первая команда запускает сессию в фоне и сразу возвращает управление. Вторая открывает экран со списком всех фоновых сессий, разложенных по состоянию: ждёт вашего ответа, работает, закончила. Из списка в любую можно войти, посмотреть и выйти обратно, не останавливая её. Уже идущую сессию отправляет в фон команда `/background`.

Как это работает внутри. За фоновыми сессиями следит служебный процесс-супервизор. Он стартует сам, держит список сессий, перезапускает упавшие и останавливает те, что час простаивают без присмотра. Его состояние лежит в папках `daemon` и `jobs` домашней директории. Сон компьютера сессии переживают, перезагрузку — нет: после неё они помечаются остановленными и продолжаются, когда вы в них войдёте.

Чтобы фоновые сессии не мешали вам и друг другу, каждая перед первой правкой переезжает в собственную рабочую копию репозитория. В основную ветку они не пушат и ничего не сливают сами.

## Как сессии и агенты взаимодействуют

Способов заставить несколько агентов работать вместе теперь четыре. Они решают разные задачи, и выбирать между ними проще, если видеть их рядом.

| | Субагенты | Сценарии (workflows) | Команды агентов | Сообщения между сессиями |
|---|---|---|---|---|
| Кто управляет | главный агент | скрипт | агент-лидер | вы или сами агенты |
| Общаются между собой | нет, только отчёт главному | нет, результаты собирает скрипт | да, напрямую | да |
| Контекст | у каждого свой, чистый | у каждого свой | у каждого свой | у каждой сессии свой |
| Число | единицы | до сотен | несколько | сколько сессий открыто |
| Когда брать | разведка, независимый кусок работы | большая однотипная работа | задача, где участникам нужно спорить и договариваться | уже идущие сессии должны обменяться сведениями |

**Субагенты** описаны выше: главный агент раздаёт задачи и получает отчёты. Между собой они не общаются.

**Сценарии** (dynamic workflows). Когда субагентов нужно много, управлять ими из разговора становится неудобно: каждый отчёт попадает в контекст главного агента. Сценарий решает это иначе. Агент пишет небольшой скрипт на JavaScript, а харнес его выполняет: запускает агентов параллельно или цепочкой, передаёт результаты из шага в шаг. Промежуточные результаты остаются в переменных скрипта и контекст не занимают. Типичный пример — проверить двадцать файлов по пяти критериям и каждую находку перепроверить отдельным агентом. Запускается словом `ultracode` в сообщении или просьбой «используй workflow». Перед запуском харнес спрашивает подтверждение, потому что десятки агентов — это десятки сессий по расходу.

**Команды агентов** (agent teams) — экспериментальная возможность, выключена по умолчанию. Здесь участники равноправнее: есть лидер и несколько напарников, общий список задач и почтовые ящики. Напарники пишут друг другу напрямую, берут задачи из общего списка и отмечают сделанное. Это подходит там, где работа требует обсуждения: один исследует гипотезу, другой её опровергает.

**Сообщения между сессиями.** Обычные независимые сессии — в соседних терминалах, в фоне — тоже могут переписываться. Агент видит список доступных собеседников и отправляет сообщение по имени сессии. На одной машине сообщения идут напрямую, через локальный канал, минуя серверы. Между машинами — через серверы Anthropic, и для этого нужен вход в аккаунт.

Здесь встроена защита, которую стоит понимать. Сообщение от другой сессии приходит как обычный текст с пометкой, от кого оно. Оно не может подтвердить запрос разрешения, поменять настройки или выполнить команду. Чужая сессия может попросить, но не приказать. А в настройках можно выбрать, что делать со входящими: доставлять, придерживать или отклонять.

## Расписание

Запускать агента по времени можно на трёх уровнях.

**Внутри сессии.** Команда `/loop 5m проверь, закончилась ли сборка` повторяет задачу, пока сессия открыта. Без интервала агент сам выбирает паузу между проверками. Работает это только пока сессия жива и простаивает.

**На вашей машине.** Приложение Desktop умеет запускать задачи по расписанию локально, с доступом к вашим файлам. Компьютер при этом должен быть включён.

**В облаке.** Команда `/schedule` создаёт задачу, которая выполняется на серверах Anthropic. Ваш компьютер может быть выключен. Запускается она по расписанию (не чаще раза в час), запросом к API или по событию в GitHub, например при открытии запроса на слияние.

## Удалённая работа

Последняя большая тема: как работать с агентом, который находится не там, где вы. Вариантов четыре, и они отличаются тем, где исполняется код.

### Удалённое управление

Агент работает на вашем компьютере, а управляете вы им с телефона или из браузера на другой машине.

```bash
claude remote-control
```

После этой команды сессия появляется на claude.ai/code и в приложении на телефоне. Оттуда можно писать сообщения, смотреть, что делает агент, подтверждать разрешения.

Как устроено соединение. Ваш компьютер сам подключается к серверам Anthropic исходящим HTTPS-запросом и ждёт сообщений. Входящих портов он не открывает, пробрасывать ничего не надо. Код, файлы, инструменты и MCP-серверы остаются на вашей машине; через серверы проходит только переписка: сообщения, ответы и сведения о вызовах инструментов.

Требования: вход через аккаунт с подпиской, с ключом API это не работает. И процесс должен продолжать работать: закрыли терминал — управление пропало.

### Облачные сессии

Здесь агент работает на виртуальной машине Anthropic. Ваш компьютер не нужен вообще.

```bash
claude --cloud "Добавь проверку формата телефона в форму регистрации"
```

То же делается с сайта claude.ai/code и с телефона. Машина получает ваш репозиторий с GitHub, агент работает в отдельной ветке и по окончании предлагает запрос на слияние.

Что стоит знать об этой среде:

- **Окружение настраивается.** Можно задать скрипт подготовки, который поставит нужные пакеты, переменные окружения и уровень доступа в сеть: никакого, ограниченный (реестры пакетов и GitHub) или полный.
- **Ключи GitHub в машину не попадают.** Они остаются на серверах Anthropic, а запросы к GitHub идут через прокси, который подставляет их сам.
- **Машина засыпает.** После нескольких минут простоя она ставится на паузу; фоновые процессы при этом не сохраняются.
- **Сессию можно забрать к себе.** Команда `/teleport` переносит облачный разговор и ветку в ваш терминал. В обратную сторону, из терминала в облако, готовую сессию перенести нельзя.

### Подключение по SSH из приложения

В приложении Desktop в списке окружений есть пункт SSH. Вы указываете адрес машины, приложение само ставит на неё Claude Code и запускает там сессию. Интерфейс остаётся у вас, а код исполняется на удалённой машине. Постоянные подключения описываются в настройках:

```json title="~/.claude/settings.json"
{
  "sshConfigs": [
    {
      "id": "dev-vm",
      "name": "Dev VM",
      "sshHost": "deploy@dev.example.com",
      "sshPort": 22
    }
  ]
}
```

### Виртуальная машина в сети: как собрать самому

Теперь частый практический случай. У вас есть своя виртуальная машина — в облаке или в локальной сети — и вы хотите, чтобы агент работал на ней. Причин обычно две. Первая — изоляция: на машине нет ваших личных файлов и ключей, и агенту можно разрешить больше. Вторая — непрерывность: машина не засыпает вместе с ноутбуком.

Claude Code — обычная программа для Linux, поэтому способов несколько.

**Способ первый: SSH и tmux.** Заходите на машину по SSH, запускаете `tmux`, в нём — `claude`. tmux нужен, чтобы сессия пережила обрыв связи: отключились, подключились снова, вернулись в тот же терминал. Это самый простой вариант, и работает он везде.

**Способ второй: удалённое управление с машины.** На машине в tmux запускаете `claude remote-control` и дальше работаете с ней с телефона или из браузера. SSH нужен только для первого запуска. Входящие порты открывать не надо, потому что машина подключается наружу сама. Для команды `claude remote-control` есть серверный режим: одна такая команда принимает несколько сессий, каждую можно запускать в своей рабочей копии репозитория.

**Способ третий: фоновые сессии.** На машине запускаете задачи через `claude --bg` и смотрите на них через `claude agents`. Супервизор держит их без открытого терминала.

**Способ четвёртый: приложение Desktop по SSH**, описанный выше. Удобен, если хочется графический интерфейс и диффы, а не терминал.

**Способ пятый: без интерфейса.** Скрипт или планировщик на машине вызывает `claude -p` с задачей. Подходит для ночных прогонов и обработки очереди.

Общий для всех способов вопрос — как войти в аккаунт на машине без браузера. Варианты такие:

| Способ входа | Что даёт | Чего не даёт |
|---|---|---|
| Обычный вход (`/login`) | всё, что есть в подписке | требует один раз открыть ссылку в браузере на другом устройстве |
| Долгоживущий токен (`claude setup-token`) | запросы к модели по подписке, удобно для скриптов | удалённое управление и браузер |
| Ключ API | запросы к модели с оплатой по токенам | всё, что привязано к подписке: удалённое управление, облачные сессии |

И пара советов из практики. Если машина выделена под агента, включите на ней песочницу: это Linux, там она работает полностью. Давайте машине отдельный ключ доступа к репозиторию с минимальными правами, а не свой личный. И помните, что изоляция машины защищает вашу систему, но не то, до чего сама машина может дотянуться по сети.

Для организаций есть ещё один вариант — свои окружения для облачных сессий. Вы запускаете на своей инфраструктуре процесс-исполнитель, он подключается к серверам Anthropic исходящим соединением, и облачные сессии из веб-интерфейса выполняются на ваших машинах, внутри вашей сети. Это бета для корпоративных тарифов.

## Провайдеры и локальные модели

Откуда берётся модель. Основных пути два: подписка Claude или ключ API с оплатой по токенам. Для компаний есть третий: модели Claude через облако — Amazon Bedrock, Google Cloud или Microsoft Foundry. Выбирается переменной окружения.

Важно понимать, что часть возможностей привязана именно к подписке и серверам Anthropic. Через облачного провайдера или по ключу API не работают удалённое управление, облачные сессии, расширение для браузера, управление компьютером, приложение Desktop. Сам цикл агента, инструменты, память, скилы, хуки и MCP работают везде одинаково.

Можно ли запустить Claude Code на чужой или локальной модели? Официально — нет: Anthropic такой режим не поддерживает. Технически адрес API подменяется переменной `ANTHROPIC_BASE_URL`, и некоторые вендоры документируют подключение своих моделей таким способом. Но системный промпт и инструменты Claude Code рассчитаны на модели Claude, и качество с другими заметно ниже. Если нужна работа на своих моделях, лучше взять харнес, который для этого сделан.

## Лимиты и стоимость

На подписке расход ограничен окнами: пятичасовым и недельным, плюс отдельные недельные лимиты на старшие модели. Они общие для всего аккаунта: терминал, приложение, облачные сессии и обычный чат тратят одну квоту. Сколько осталось, показывает `/usage`; там же видно, что именно расходует лимит — какие скилы, субагенты и MCP-серверы.

По ключу API лимитов по окнам нет, оплата идёт за токены. Для ориентира: документация называет среднюю цифру около 13 долларов на разработчика за активный день.

Из устройства, описанного выше, прямо следует, что именно стоит дорого:

- **Длинная сессия после паузы.** Кэш остыл, и весь разговор оплачивается заново.
- **Параллельные агенты.** Каждый субагент, напарник или фоновая сессия — отдельный разговор со своим контекстом.
- **Высокое усилие и старшая модель** там, где задача этого не требует.
- **Задачи по расписанию.** Каждое срабатывание отправляет полный контекст.
- **Раздутые инструкции.** Они оплачиваются в каждом запросе каждой сессии.

## Что уходит с вашей машины

Короткая, но важная часть.

**Что отправляется.** На серверы Anthropic уходит то, что попало в запрос: ваши сообщения, содержимое прочитанных файлов, вывод команд, ответы модели. Файлы, которые агент не читал, никуда не отправляются.

**Обучение.** На личных тарифах использование ваших данных для обучения моделей — это переключатель в настройках приватности. На корпоративных тарифах и по API данные для обучения по умолчанию не используются.

**Хранение на серверах.** По умолчанию 30 дней; если на личном тарифе разрешено обучение — до пяти лет.

**Хранение у вас.** Разговоры лежат в домашней папке открытым текстом 30 дней. Об этом стоит помнить, когда агент читает файлы с секретами.

**Телеметрия.** Метрики использования и отчёты об ошибках отключаются переменными окружения; одна переменная выключает весь необязательный трафик сразу.

**Защита от вредных инструкций.** Текст, который агент прочитал на веб-странице, в файле или в ответе инструмента, может содержать команды, адресованные ему. Против этого работает несколько слоёв сразу: запросы разрешений, пересказ веб-страниц отдельной моделью, окно доверия для новой папки, подтверждение для MCP-серверов проекта. Ни один слой не даёт гарантии. Поэтому с недоверенным содержимым — чужой репозиторий, незнакомые сайты — разумно работать в изолированной среде.

## Чем Claude Code отличается от похожих инструментов

Все современные харнесы для программирования устроены по одной схеме: цикл, инструменты, инструкции проекта, разрешения. Отличаются они решениями в деталях. Коротко о главных; подробное сравнение сорока с лишним инструментов — в [отдельной статье](/ru/ai-agent-harnesses/).

| | Claude Code | Codex | Cursor | GitHub Copilot | OpenCode |
|---|---|---|---|---|---|
| Кто делает | Anthropic | OpenAI | Anysphere | GitHub | сообщество, команда SST |
| Исходный код | закрыт | CLI открыт | закрыт | CLI закрыт, расширение открыто | открыт |
| Главная форма | терминал | терминал и облако | свой редактор | редактор и GitHub | терминал |
| Модели | только Claude | модели OpenAI | многих вендоров | многих вендоров | любые, включая локальные |
| Инструкции | `CLAUDE.md`, правила по путям | `AGENTS.md` | `.cursor/rules` | `copilot-instructions.md` | `AGENTS.md` |
| Поиск по коду | агентный, без индекса | агентный | индекс с эмбеддингами плюс агентный | индекс плюс агентный | агентный |
| Песочница | по желанию; нет на Windows без WSL | включена по умолчанию на трёх ОС | включена на macOS и Linux | по желанию | нет |
| Облачный режим | есть | есть | есть | есть | нет |

Что из этого следует на практике.

**Сильные стороны Claude Code** — глубина настройки и работа без присмотра. Четыре уровня инструкций, правила с привязкой к путям, скилы, субагенты со своей моделью, три десятка событий для хуков, моды, сценарии с десятками агентов, фоновые и облачные сессии. Ни у кого больше нет такого набора целиком.

**Слабые стороны** — закрытый код и привязка к одному вендору. Работать можно только с моделями Claude, а подписка действует только в продуктах Anthropic. Песочница не включена по умолчанию и не работает на Windows без WSL — у Codex она включена сразу и на всех трёх системах.

**Что переносится.** Файлы из папки `.claude` стали чем-то вроде общего формата: скилы, правила и хуки частично читают Cursor, Copilot, OpenCode и другие. А `AGENTS.md`, который понимают почти все, Claude Code читает, если нет своего файла инструкций. Команда `/import` переносит настройки в обратную сторону — из Codex, Gemini CLI и Cursor.

## Коротко

- Claude Code — это харнес: программа на вашем компьютере, которая даёт модели инструменты и управляет тем, что модель видит. Модель думает, харнес делает.
- Работа идёт циклом: модель просит вызвать инструмент, харнес выполняет и возвращает результат, и так до ответа без вызовов. Каждый запрос несёт весь разговор.
- Правка файла — это точная замена уникального фрагмента. Поиск — обычный поиск по файлам, без индекса.
- Контекст сжимается сам. Переживает сжатие то, что записано в файлы: инструкции, правила, память. Сказанное только в чате может потеряться.
- Знание передаётся тремя способами: инструкции и правила (всегда в контексте), скилы (по требованию), авто-память (пишет сам агент, лежит в домашней папке).
- Субагент — отдельный контекст для отдельной задачи. Экономит главный контекст, но теряет детали на передаче и стоит как ещё одна сессия.
- Хук — код, который харнес выполняет сам. Всё, что должно происходить всегда, делается хуком, а не строчкой в инструкциях.
- Разговоры, память и копии файлов лежат в `~/.claude` открытым текстом. Настройки проекта — в `.claude` в репозитории.
- Разрешения и авто-режим защищают от случайностей. Настоящую границу дают песочница, контейнер и виртуальная машина.
- Один движок работает в терминале, редакторе, приложении, облаке и без интерфейса. На своей виртуальной машине он запускается как обычная программа для Linux, а управлять им можно с телефона, не открывая портов.

## Источники

- [How Claude Code works](https://code.claude.com/docs/en/how-claude-code-works) — цикл агента, контекст, сессии.
- [Tools reference](https://code.claude.com/docs/en/tools-reference) — все встроенные инструменты и их поведение.
- [Explore the context window](https://code.claude.com/docs/en/context-window) — что загружается в контекст и что переживает сжатие.
- [Explore the .claude directory](https://code.claude.com/docs/en/claude-directory) — файлы проекта и домашней папки.
- [Memory](https://code.claude.com/docs/en/memory), [Skills](https://code.claude.com/docs/en/skills), [Subagents](https://code.claude.com/docs/en/sub-agents), [Hooks](https://code.claude.com/docs/en/hooks), [MCP](https://code.claude.com/docs/en/mcp).
- [Permission modes](https://code.claude.com/docs/en/permission-modes), [Permissions](https://code.claude.com/docs/en/permissions), [Sandboxing](https://code.claude.com/docs/en/sandboxing), [Security](https://code.claude.com/docs/en/security), [Data usage](https://code.claude.com/docs/en/data-usage).
- [Checkpointing](https://code.claude.com/docs/en/checkpointing), [Worktrees](https://code.claude.com/docs/en/worktrees), [Development containers](https://code.claude.com/docs/en/devcontainer).
- [Claude in Chrome](https://code.claude.com/docs/en/chrome), [Computer use](https://code.claude.com/docs/en/computer-use), [Desktop](https://code.claude.com/docs/en/desktop).
- [Remote Control](https://code.claude.com/docs/en/remote-control), [Claude Code on the web](https://code.claude.com/docs/en/claude-code-on-the-web), [Self-hosted environments](https://code.claude.com/docs/en/self-hosted-environments).
- [Headless mode](https://code.claude.com/docs/en/headless), [Agent view](https://code.claude.com/docs/en/agent-view), [Agent teams](https://code.claude.com/docs/en/agent-teams), [Workflows](https://code.claude.com/docs/en/workflows), [Cross-session messaging](https://code.claude.com/docs/en/cross-session-messaging).
- [Model configuration](https://code.claude.com/docs/en/model-config), [Costs](https://code.claude.com/docs/en/costs), [Feature availability](https://code.claude.com/docs/en/feature-availability).
