512 000 строк утекшегокода. 44 feature‑флага. Система питомцев в духе тамагочи. Имена вроде «Tengu», «Fennec» и «Penguin mode». Всё это — то, о чём написали сотни новостей. Но не это главное.

Пока интернет разбирал по косточкам внутренности Claude Code, увлечённо споря, игрушка это или серьёзная архитектура, настоящая ценность утечки осталась почти незамеченной. Anthropic случайно показала миру не список фич. Она показала, как на самом деле думает её ИИ‑агент.

За милыми именами и игровыми механиками скрывается жёсткая инженерная реальность: самовосстанавливающийся цикл запросов, вычисления во сне и двухуровневая система отсечения функций. Это уже не обёртка над API. Это операционная система для ИИ. И сегодня мы разберём три паттерна, которые делают Claude Code не просто дорогим автокомплитом, а продуктом на 2,5 млрд $ в год.

31 марта 2026 года тысячи разработчиков по всему миру сделали одно и то же: скормили Claude его собственный исходный код — и попросили объяснить, как он устроен.

Флагманский CLI‑инструмент от Anthropic слил весь свой TypeScript‑код — 512 000 строк — через source map, по ошибке упакованный в npm‑пакет. Буквально за считаные часы интернет разобрал находку по косточкам: насчитали 44 feature‑флага, откопали систему питомцев в духе тамагочи с 18 видами и механикой гачи, а заодно вытащили внутренние кодовые имена вроде «Tengu», «Fennec» и «Penguin Mode».

Но список функций — не суть истории. Об этом уже все написали. Настоящая ценность утечки не в том, что умеет Claude Code, а в том, как он мыслит.

Обвязка и есть продукт

Большинство считало Claude Code тонкой CLI‑оболочкой поверх API Claude: терминальный интерфейс, который отправляет запрос, стримит ответ и умеет немного работать с файлами.

Но утёкший код рассказывает совсем другую историю. На деле Anthropic поставила продукт из 512 000 строк TypeScript: особый терминальный рендерер на React с двойной буферизацией вывода и flexbox‑разметкой через Yoga, более 60 инструментов с разграничением прав и отложенной подгрузкой, систему оркестрации мультиагентов, которая запускает и координирует параллельных «исполнителей», фоновый движок консолидации памяти, работающий, пока вы спите, и самовосстанавливающийся цикл запросов, который попросту не падает.

Это не обёртка. Это операционная система для ИИ‑агента.

Сообщество Hacker News раскололось на два лагеря. Одни отмахнулись от утечки, сравнив её с казино: «Исходный код игрового автомата неинтересен владельцу казино». Модель — вот где деньги. CLI — расходный материал. Другие увидели всё наоборот: модель — это крупье. Обвязка — это казино. А казино строить чертовски трудно.

Цифры — на стороне второй группы. Opus 4.6 доступен всем через API по цене 5/25 $ за миллион токенов. Но по данным VentureBeat, один только Claude Code приносит 2,5 млрд $ годовой выручки по подписке, причём 80% — за счёт корпоративных клиентов. Разработчики платят не за модель. Они платят за обвязку, которая делает модель полезной: оркестрацию инструментов, систему прав, управление контекстом, восстановление после ошибок. Уберите это — и останется просто дорогой автокомплит.

Замкнутый контур дохода, возникший 31 марта, делает это особенно наглядным. Один разработчик поднял MCP‑сервер специально для того, чтобы можно было интерактивно исследовать утёкший Claude Code через сам Claude Code. Другой в 04:00 утра переписал его ключевую архитектуру на Python — ещё до рассвета. Команда из Китая собрала из утечки курс по реверс‑инжинирингу на 12 занятий. А разработчик Jingle Bell сформулировал происходящее в одной фразе: «Сегодняшняя выручка Claude — это люди, которые используют Claude, чтобы разбирать исходники Claude».

Обвязка создаёт спрос на модель. Модель приносит деньги обвязке. Этот маховик и есть продукт.

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

Паттерн 1: Самовосстанавливающийся цикл запросов

Самая дорогая часть инженерии в Claude Code — вовсе не ИИ. Это обработка ошибок.

В самом сердце Claude Code — цикл обработки запросов. Не примитивная схема «запрос — ответ», а полноценная машина состояний на while(true), которая из итерации в итерацию ведёт изменяемое состояние. И у неё есть один жёсткий принцип: пользователь никогда не должен увидеть сырую ошибку.

Каждая итерация разворачивается по одному и тому же сценарию. Сначала параллельно подгружаются память и «навыки» (а не последовательно — иначе задержка удвоилась бы). Затем, если контекст разрастается, включается сжатие сообщений. После этого — стриминговый вызов API. Дальше исполняются инструменты, которые запросила модель. И в конце принимается решение: идти на следующий круг или завершать. При этом на каждом шаге цикл фиксирует, почему он не остановился, записывая причину перехода в состояние — чтобы следующая итерация могла скорректировать поведение.

Но настоящая инженерия начинается там, где всё ломается. Когда происходит сбой, цикл не падает — он методично перебирает цепочку всё более жёстких стратегий восстановления:

• Микросжатие. Удаляются наименее значимые сообщения, освобождая токены.

• Схлопывание контекста. Если этого мало, целые фрагменты диалога сворачиваются в краткие сводки.

• Эскалация токенов. Если модель исчерпала лимит вывода посреди задачи, ей незаметно подсовывают служебное сообщение («Продолжай сразу, без извинений и повторов») — и цикл идёт дальше. Не более трёх попыток подряд, после чего причина остановки всё‑таки раскрывается.

• Резервная модель. Если основная модель недоступна, подключается альтернативная.

• Показ ошибки. И только если исчерпаны все варианты, пользователь, наконец, видит сбой.

Один из разработчиков, разобравший двенадцать версий Claude Code по минифицированному JavaScript, обнаружил любопытную деталь: 5,4% всех вызовов инструментов «осиротевали» — модель вызывала инструмент, тот отрабатывал, но результат до неё так и не возвращался. Самовосстанавливающийся цикл как раз и рассчитан на то, чтобы поглощать подобные сбои — незаметно для пользователя.

Исполнение инструментов добавляет ещё один уровень сложности. Цикл не запускает их по одному — он разбивает вызовы на группы в зависимости от того, безопасны ли они для параллельного выполнения. Каждый инструмент сам сообщает об этом через метод isConcurrencySafe(). Читающие операции (grep, glob, чтение файлов) могут выполняться параллельно — до десяти одновременно. Записывающие (редактирование файлов, bash‑команды с побочными эффектами) — строго по очереди. Пакеты чередуются: чтение, запись, снова чтение. Более того, потоковый исполнитель может начать запуск инструментов ещё до того, как модель закончила генерировать ответ, накладывая вычисления и ввод‑вывод друг на друга и тем самым снижая задержку.

Сами инструменты подчиняются той же философии — ничего лишнего в контексте. Из более чем 60 инструментов Claude Code примерно 40 загружаются в каждый запрос. Остальные 18 помечены как отложенные: модель о них не знает, пока не найдёт их через специальный ToolSearchTool. Как только возникает потребность — будь то интеграция с LSP, запуск фоновых задач или настройка cron — модель ищет инструмент, получает его схему и тут же вызывает, в рамках той же итерации. Для пользователя всё выглядит как обычно. Зато контекстное окно остаётся легче примерно на 200 тысяч токенов — потому что ненужные схемы туда просто не попали.

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

Вывод, который поначалу звучит парадоксально: в агентных системах надёжность — не надстройка. Она и есть ядро. Основной цикл и есть система обеспечения надёжности. Движок запросов Claude Code занимает 46 тысяч строк не потому, что «счастливый путь» сложен, а потому, что всё остальное — куда сложнее.

Как не потеряться в многообразии ИИ-моделей

Хотите разобраться в архитектуре ИИ-агентов на практике?

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

BotHub собирает ведущие мировые нейросети в одном окне. Тестируйте гипотезы, воспроизводите паттерны из статьи, стройте собственных агентов — без VPN и сложностей с оплатой.

Изучать архитектуру по исходникам — полезно. Проверять её на живых моделях — ещё лучше.

Для доступа не требуется VPN, можно использовать российскую карту.

По ссылке вы можете получить 300 000 бесплатных токенов и приступить к работе с нейросетями прямо сейчас!

Паттерн 2: Вычисления во сне

Самое важное, что делает Claude Code, происходит тогда, когда вы им не пользуетесь.

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

Ответ Claude Code — система под названием autoDream. И это не случайное имя. Это буквально сон Клода.

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

Но этот «сон» не случается когда вздумается. У него есть три условия — трое «ворот», и все они должны открыться, прежде чем начнётся консолидация.

• Ворота 1: время. С момента последнего «сна» должно пройти не менее 24 часов. Это защищает от чрезмерной переработки данных, если вы работаете короткими сессиями, но часто.

• Ворота 2: сессии. Должно накопиться как минимум пять сессий. Иначе просто нечего осмыслять.

• Ворота 3: блокировка. Подагент обязан получить «замок» на консолидацию. Это исключает одновременные «сны», если запущено несколько экземпляров Claude Code.

Когда все три условия выполнены, запускается четырёхфазный процесс.

• Фаза 1 — ориентация. Просмотреть директорию памяти. Прочитать индексный файл (MEMORY.md). Быстро пробежаться по тематическим файлам, чтобы понять текущее состояние.

• Фаза 2 — сбор сигналов. Найти в недавних источниках информацию, достойную сохранения. Приоритет жёсткий: сначала дневные логи, затем «дрейфующие» факты (то, что изменилось), затем поиск по транскриптам — в попытке выловить закономерности, замеченные моделью в работе.

• Фаза 3 — консолидация. Обновить или переписать файлы памяти. Перевести относительные даты («вчера») в точные («30 марта 2026 года»). Удалить устаревшие или противоречащие новым данным факты. Слить дубликаты.

• Фаза 4 — обрезка и индекс. Держать MEMORY.md в пределах 200 строк и примерно 25 КБ. Убирать устаревшие ссылки. Разруливать противоречия. Индекс должен оставаться настолько компактным, чтобы его можно было безболезненно подгружать в каждую новую сессию.

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

Эта архитектура перекликается с идеей «вычислений во сне» из исследований UC Berkeley: использовать простаивающие ресурсы, чтобы ускорить будущие выводы. В тех работах предлагается заранее предсказывать возможные будущие запросы на основе накопленного контекста. autoDream смотрит не вперёд, а назад: он не угадывает будущее, а приводит в порядок прошлое. Но логика та же — тратить вычисления тогда, когда пользователь не ждёт, чтобы следующая сессия начиналась быстрее и с более осмысленным контекстом.

В итоге получается четырёхслойная архитектура памяти — такой в продакшен‑инструментах для программирования ещё не было.

• Слой 1: CLAUDE.md. Инструкции, которые пишете вы. Статичные, всегда загружаются.

• Слой 2: автопамять. Заметки, которые Claude ведёт по ходу каждой сессии: команды сборки, находки при отладке, архитектурные решения, ваши предпочтения. Нарастает сама.

• Слой 3: память сессии. Непрерывность диалога в рамках одной сессии — обычное управление контекстным окном.

• Слой 4: autoDream. Периодическая сборка мусора и переупаковка всего накопленного в слоях с первого по третий. Очистка. Дефрагментация. Фаза быстрого сна.

• Инструкция, записная книжка, кратковременная память и фаза сна. Это уже не набор функций. Это зачатки когнитивной архитектуры.

Паттерн 3: Устранение функций на этапе компиляции

Утечка source map произошла именно потому, что система безопасности… сработала. Код действительно вырезали из сборки. Просто забыли вырезать его из карты.

Anthropic поставляет одну и ту же кодовую базу двум аудиториям. Внутренние сотрудники получают KAIROS (всегда активного помощника), BUDDY (компаньона в духе тамагочи), Coordinator Mode (оркестрацию мультиагентов), Voice Mode, Bridge Mode и ещё с десяток экспериментальных подсистем. Внешние пользователи — ничего из этого. Во внешней сборке нет «мёртвого» кода, спрятанного за if. Его там нет физически — ни байта в исполняемом файле.

Механизм основан на функции feature() из Bun, которая вычисляется не во время выполнения, а на этапе сборки. Когда Anthropic собирает внешний пакет, каждый вызов feature('KAIROS') превращается в константное false. Сборщик Bun затем полностью вырезает соответствующую ветку как «мёртвый код». В итоговом JavaScript не остаётся ни следа от KAIROS, BUDDY или любой другой закрытой подсистемы: ни строк, ни функций, ни импортов. Как будто их никогда и не было.

Это первый уровень двухуровневой системы управления функциями.

Второй уровень — управление на этапе выполнения через GrowthBook, платформу feature‑флагов. Флаги (в коде они идут с префиксом tengu_) отвечают за постепенные выкаты, A/B‑тесты и «рубильники» для уже допущенных в релиз функций. Проверяющая их функция названа показательно: getFeatureValue_CACHED_MAY_BE_STALE(). В этом названии зашито инженерное решение: устаревшие данные допустимы. Скорость важнее актуальности. Агент не должен тормозить, ожидая ответа по флагу.

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

Сверху добавлен третий слой: проверки вида USER_TYPE === 'ant', открывающие возможности только для сотрудников Anthropic. Сюда входят доступ к staging API, дамп отладочных промптов, Undercover Mode (режим, при котором Claude не раскрывает, что он ИИ, в публичных опенсорс‑вкладках), а также внутренние инструменты вроде ConfigTool и TungstenTool.

Ирония, позволившая этой утечке случиться, — в самой структуре системы. Source map существует, чтобы связать скомпилированный код с исходниками. Он хранит оригинальный код в массиве sourcesContent — независимо от того, что именно компилятор вырезал. Удаление «мёртвого» кода защищает исполняемый файл, но не карту. Bun генерирует source map по умолчанию. Никто это не отключил. Никто не добавил *.map в .npmignore. В итоге весь внутренний код оказался в npm — в виде JSON‑файла на 59,8 МБ.

И это не первый случай. Та же проблема всплывала в феврале 2025 года, при первом запуске Claude Code. Тогда её тихо убрали. Через тринадцать месяцев, в версии 2.1.88, она вернулась. Конвейер сборки так и не починили. Настройки Bun не переопределили. Компания с лучшей языковой моделью в мире, придумавшая undercover mode, чтобы скрывать внутреннюю кухню, споткнулась о одну пропущенную строчку в .npmignore.

Вывод здесь не в курьёзе, а в конструкции. Если вы делаете агентный продукт, вам нужна двухуровневая система управления функциями: устранение на этапе компиляции — для безопасности (что не должно существовать вовсе) и флаги времени выполнения — для управления выкладкой (что существует, но выключено). И наконец, конвейер сборки, который проверяет, что именно вы публикуете. npm pack --dry-run перед каждым релизом. Без исключений.