Два дня — и у меня появился агент, который помнит кто я и что делаю.

Не в смысле "запомни это на потом". В смысле: открываю новую сессию — агент уже в контексте. Знает проекты, принципы, как со мной работать.

Сделал три файла: кто я (SOUL.md), кто клиенты и что в работе (UFC-файлы по проектам), как агент должен себя вести (CLAUDE.md). Это всё. Агент читает их при старте и не задаёт вопросы, на которые ответ уже есть.

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

Сейчас думаю: насколько вообще можно делегировать мышление? Или только исполнение?

Веду 4-5 клиентских проектов одновременно. Каждый — свой контекст, свои задачи, свои договорённости.

В какой-то момент понял: нет единой рабочей среды. Есть набор инструментов, которые не знают друг о друге.

Собрал схему, которая работает. Три инструмента:

Notion — контрольная панель. Задачи, метрики, стримы. Только структурированные данные.

Obsidian — мозг. UFC-файлы (живой контекст каждого проекта), заметки, связи. Граф, который показывает что на что влияет.

Syncthing — синхронизация. P2P, без облака. Обычная папка, которая всегда одинакова на всех машинах.

Самое важное: агент читает UFC-файлы напрямую. Без объяснений «кто такой клиент и что происходит» — просто берёт контекст из файла.

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

Confluence переучивает. Obsidian — нет.

Как у тебя устроена рабочая среда при нескольких параллельных проектах?

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

Сейчас выхожу на прогулку с телефоном и надиктовываю всё вслух. Задачи, мысли, брифы, вопросы. Агент получает голосовое, транскрибирует, разбирает, кладёт в нужный контекст.

Возвращаюсь — уже есть результат.

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

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

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

Интересно, у кого как с этим?

Собрал свой сетап и решил поделиться.

Это markdown файл — бросаешь его как CLAUDE.md в Claude Code или Codex, агент запускает мастер настройки, задаёт тебе пару вопросов и собирает под тебя готовую систему.

Что внутри после настройки:

Память. Агент помнит кто ты, как работаешь, что уже решено по проектам — между сессиями. Не нужно каждый раз объяснять контекст заново.

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

UFC-файлы. Один файл на каждый проект: суть, статус, открытые вопросы. Агент читает его перед каждой задачей.

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

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

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

Система базовая — под себя потом дотачиваешь, подключаешь Notion, MCP-сервисы, любые инструменты. Но база уже оптимизирована: память, контекст, лучшие практики работы с агентом.

Файл в следующем сообщении.

agent_setup_wizard.md

«Напиши мне анализ» — это не задача. Это просьба угадать.

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

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

Работает как с человеком: новому сотруднику не говоришь «напиши анализ». Говоришь — кто ты в этой задаче, зачем это нужно, что уже известно, что хочешь получить.

Мой рабочий шаблон сейчас:

1. Роль — кто агент в этом контексте
2. Контекст — что происходит, что важно знать
3. Задача — конкретно что сделать
4. Формат — как именно отдать результат

С этим даже голосовая заметка на ходу превращается в структурированный вывод. Потому что агент работает с тем же полем что я, а не угадывает.

Проблема не в модели. Проблема в том что мы даём задачу без среды в которой она живёт.

Интересно — у кого уже сложился свой шаблон?

Агент не помнит.

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

Я долго пытался решить это «правильными промптами». Не работало. Потом понял: проблема не в промпте, а в том, что информация нигде не живёт постоянно.

Теперь у меня есть несколько файлов, которые агент читает при каждом старте. UFC — это «Ultra-Fast Context», один файл на проект: кто мы, где находимся, что решили, что открыто. ARTIFACTS.md — карта всех артефактов по стримам, чтобы агент не искал что существует, а сразу знал куда смотреть. MEMORY.md — долгосрочная память: решения, контекст, то что нельзя терять между сессиями.

Принцип такой: контекст из файлов, не из памяти разговора.

Это меняет не только скорость. Меняет характер взаимодействия. Агент перестаёт быть «умным поиском по прошлому диалогу» и становится чем-то ближе к коллеге, который уже в теме.

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

Получается агент не забывает — это я забываю его кормить.

Не знаю хорошо это или нет.

Когда-то я думал, что хороший промпт — это и есть решение.

Дал задачу. Получил ответ. Готово.

Потом задачи стали сложнее. Промпт вырос до 3000 токенов. Начал добавлять «а ещё учти, что…» — и понял, что пишу код. Только плохой.

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

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

Пришлось добавить точки остановки. Явные проверки. Места где система сама тормозит и спрашивает: это всё ещё верно?

Сейчас работает 5-6 агентов параллельно по разным проектам. Каждый знает свою зону. Каждый пишет в лог. Есть оркестратор который знает текущее состояние всей системы.

Не скажу что это элегантно. Местами это честный набор костылей.

Но работает.

Интересно — у кого как устроена многоагентность? Всё сами собираете или всё ещё один большой промпт?

Два года считал, что агент — это про автоматизацию. Сделать, написать, найти.

Потом начал использовать иначе: как партнёра по рефлексии.

Каждое утро — один вопрос. Не про задачи. «Где ты принимаешь решения на автопилоте?» «Что откладываешь три месяца, притворяясь что не срочно?» Отвечаю голосовым, 10 минут.

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

Из этих разборов постепенно вытаскиваю ритуалы. Ничего радикального — маленькие якоря утром и вечером. Тестирую, записываю что даёт энергию, что забирает.

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

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

Куда это придёт — не знаю. Но рефлексия теперь встроена в систему, а не висит в голове.

«Оно ошибается, а я не знаю где» — в какой-то момент это говорит каждый кто строит что-то с AI.

Обычная реакция: поменять модель. Другой промпт. «Будь точнее». Потом ещё один промпт.

Не работает. Потому что проблема не в модели.

Первое что надо понять: ИИ не должен делать то, что лучше делает скрипт.

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

Практики для задач где ИИ реально нужен:

Попроси думать вслух
Не «напиши ответ», а «сначала объясни как понял задачу, потом отвечай». Ты видишь где агент свернул не туда. Баг находится за 30 секунд вместо часа перебора.

Критерии приёмки до запуска
Перед запуском формулируй: хороший результат выглядит так. Нужные поля есть. Длина в пределах X. Тон такой. Без этого оцениваешь по ощущению. Ощущение — дорогой инструмент контроля.

Evals — юнит-тесты для языка
10–20 примеров входов с правильными выходами. После изменения промпта — прогоняешь и смотришь сколько попало. Единственный способ знать «реально стало лучше или мне показалось».

И два принципа которые идут поверх:

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

Система которая учится на обратной связи
Каждое исправление которое ты делаешь — данные. Логируй их. Накапливается: вот что не работало, вот что исправляли, вот почему. Это и есть твои evals следующего поколения. Система не умнеет сама — она умнеет через тебя, если ты это настроишь.

Разница между AI-игрушкой и рабочим инструментом — не в том какая модель внутри. В том есть ли у тебя контроль и обратная связь.

Долго думал, чем «агент» отличается от «чата».

Чат — это я открыл ноут, написал вопрос, получил ответ. Я внутри процесса, я и есть итерация.

Агент — это когда он что-то делает, пока меня нет.

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

Вот что у меня сейчас работает автономно:

— Агент мониторит контекст по проектам и утром собирает: что изменилось, что застряло, что надо апрувнуть. Я получаю в Telegram, а не листаю доску.

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

— Контент-цикл: агент выбирает тему, пишет драфт, присылает мне апрув. Я нажимаю «ок» или правлю голосовым.

Каждая из этих задач занимает у агента 5–20 минут. Я в этом не участвую — только в точках решения.

Как это устроить. Три вещи:

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

Плейбуки для повторяющегося — что делать «когда клиент не отвечает», «как опубликовать пост», «как начать задачу». Один раз описал — агент следует.

Ритуалы с триггером — деброиф в 21:00, бриф в 8:00, контент в понедельник. Не «когда захочу» — конкретное время.

Вопрос: если убрать тебя из процесса на три часа — агент продолжит? Или просто будет ждать следующего вопроса?

Классический вопрос — как сделать так, чтобы AI помнил тебя через месяц?

Ответ: сам LLM — никак. Каждая сессия — чистый лист. Но то что помнит — система вокруг него.

Вот как это устроено у меня прямо сейчас.

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

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

Главное что я понял: у LLM плохая дисциплина с рутиной. «Обнови индекс, запиши путь к файлу» — пропустит. Поэтому я вынес это в скрипты. Появился новый файл в папке проекта — скрипт сам добавляет его в индекс. Ничего не прошу — оно просто работает.

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

LLM здесь не хранилище. LLM — процессор.

Как у тебя с этим устроено?

Заметил за собой странную вещь.

Три часа назад я описывал что должен делать мой PM - подробно, по шагам. Матрица ответственности. Ритуалы. Источники данных. Повестка передаточного звонка.

Всё ради того чтобы самому меньше делать.

Потом агент задал вопрос: "Назови одну вещь которую сам должен прекратить делать прямо сейчас. Не передать - именно остановить."

Я написал список. Сбор метрик. Отчёты. Jira. Статус-синки. Всё правильно, всё не моя работа. Но всё это - делаю я.

Первый ответ на вопрос "почему" - контекст у меня, быстрее самому. Звучит разумно.

Второй ответ, честный: если PM сделает и сделает не так - я несу ответственность. Если делаю сам - нет риска. И пока не назвал это вслух - не замечал.

AI внедрил без особых тормозов. Делегирование живому человеку - застрял там где не ожидал.

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

Не знаю универсально ли это - или это про меня конкретно.

Большинство PM-систем учат планировать задачи.

Но задачи — это симптом. Принципы — первопричина.

Объясню что происходит у меня прямо сейчас.

У меня два слоя. Быстрый и медленный.

Быстрый — это спринт. Задачи в Notion, статусы, дедлайны. Видно, понятно, двигается. Но если этот слой ни к чему не привязан — он просто генерирует красивую видимость занятости. Знаю по себе.

Медленный — это mind.os. Текстовый файл. В нём не задачи, а правила: что P1, а что фон. Паттерны которые я замечаю в проектах. Мои когнитивные ловушки (и где агент должен меня притормозить). Цикл от принятия решения до фиксации результата.

Эти два слоя связывает MCP.

Сегодня утром вместо того чтобы листать Notion вручную, я запустил двух агентов параллельно. Один пошёл в базу синков — собрал 10 звонков за 2 недели по трём проектам. Другой — в задачи спринта, 26 штук. Оба вернули структуру. Я — синтезировал.

Работает потому что через MCP агент видит Notion так же как я. И файловую систему тоже. Никакого copy-paste, никакого «ну расскажи что там было на прошлой неделе».

Дальше — медленная система делает своё: я смотрю на результат через призму правил из mind.os. Вижу паттерн (в одном из проектов блокер завис на 2 недели и никто не эскалировал). Добавляю правило в файл. Маховик сделал один оборот.

Схема:
синки → агенты собирают → я синтезирую → обновляю правила → следующий спринт планирую из правил, не из ощущений

Это не про автоматизацию. Это про то, как перестать быть диспетчером задач.

Build in progress. Маховик раскручивается.

Я и мой AI-агент: год спустя

Начинал с ChatGPT — просил написать код, редактировал, запускал. Казалось, это уже много.

Потом Cursor. Почти не писал руками — подсказывал, направлял, принимал или отклонял.

Потом перестал кодить совсем.

Сейчас общаюсь с агентом в Telegram. Он подключён к данным, контексту, базам. Я говорю голосом что нужно — он делает. Настраиваю систему, структурирую данные, обновляю контекст. Это стал отдельный тип работы.

Где я сейчас — понимаю. Куда дальше — пока нет.

Хочется в сторону автономности. Есть тема «рой агентов» — несколько агентов работают параллельно и между собой. Как это строить, что для этого нужно — честно не понимаю. Буду разбираться.

Что понял за это время:

Точка принятия решений — твоя ответственность. Ответ агента не равно решение. Нужно всегда держать: где заканчивается инструмент и начинаешься ты.

Когнитивные мышцы реально атрофируются. Если агент думает за тебя — ты перестаёшь думать. Ввёл для себя thinking practice: агент задаёт вопросы на основании контекста, я думаю и отвечаю вслух, грумим вместе. Не за ответом — чтобы не разучиться думать.

Встречаю сопротивление коллег. Думаю, временно. Показываю на практике — не убеждаю словами.

Что остаётся моим: креативность, насмотренность, игривость. И привычка фиксировать что работает, что нет. На уровне правил, proven learnings. Это не агент делает. Это я.

Вот где я. Интересно что будет дальше.

«Почти готово. Ещё пару доработок — и выйдем.»

Я называю это техническим избеганием.

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

Это не перфекционизм. Это отсутствие контакта с реальностью.

Пока ты доделываешь — реальность молчит. Каждый день в «почти готово» — это день без данных.

Ясность появляется не когда додумаешь. Она появляется в момент действия.

Запустил трафик → получил отклик.
Отправил оффер → получил ответ.
Выпустил фичу → увидел поведение.

Быстрый контакт с реальностью важнее правильного запуска.

📌 /start отсюда

Я Алекс. CPO продуктового агентства. Строю AI-агентов для работы и жизни — и делюсь тем, что реально работает, а что не очень.
Пишу про AI системы, Personal OS, когнитивные паттерны и продуктовое мышление.

Кстати, канал наполовину ведёт мой AI-агент. Он читает мои заметки, синтезирует контекст, предлагает темы, пишет посты и дистрибуцирует их на другие площадки.
Пайплайн такой: Я думаю — он формулирует. Я апрувлю — Вы читаете (но это не точно).

Добро пожаловать в New World.

🔹 Почему AI-агент — это не умный чат главное отличие, которое меняет подход
🔹 Mind.OS: как я нашёл 15 багов в своей прошивке — когнитивные искажения, Харада, и почему ясность — побочный эффект действия, а не его условие
🔹 Плейбук по настройке AI-агента — просто скинь своему Клодику чтобы он настроил

Как работают AI-агенты:

⚙️ Как сделать так, чтобы AI запомнил тебя через месяц
⚙️ Как ставить задачи агентам, чтобы получать результат
⚙️ Галлюцинации — не проблема модели, проблема архитектуры

Из личной практики:

🗂 Год с AI-агентом: что реально изменилось
🗂 Как я перестал делать работу своего PM
🗂 Техническое избегание — когда "почти готово" не заканчивается

Мои органик-воронки (подпишись тоже):

Лонгриды на VC | Threads шитпостинг

Собираю отчёт за 3 минуты. Год назад уходил час.

Секрет не в том, что LLM стал умнее. В том, что я перестал отдавать ему задачи, которые должен делать скрипт.

Архитектура:
— Скрипт заходит в Notion, вытаскивает задачи, считает время, собирает синки — всё структурировано
— LLM получает уже готовую структуру и пишет по шаблону
— Я дочитываю и правлю голосом или руками — 2-3 минуты

Если дать LLM «напиши отчёт» без данных — он придумает. Или спросит. Или галлюцинирует. Потому что у него нет фактов — только контекст.

Скрипт не думает. Он считает, структурирует, вытаскивает.
LLM не считает. Он обрабатывает, формулирует, видит паттерны.

Перепутать роли — значит получить медленный и дорогой результат.

В итоге вместо «напиши отчёт» у меня промпт с подготовленными данными. LLM закрывает анализ. Я правлю 20%.

Принцип работает везде где есть данные. Не только в отчётах.

Почему у тебя кончаются токены раньше чем кончается задача

Потому что ты запускаешь команду там где хватило бы скилла.

Лабы придумывают красивые слова. Каждое следующее стоит экспоненциально дороже. Без маркетинга:

1 — Чат. Пишешь агенту, он отвечает, делает действия. Базово. Дёшево.

2 — Скилл. Написал одно и то же три раза → «создай skill.md». Повторяемая инструкция — агент сам вспоминает.

3 — Цель. Агент крутится в петле пока не убедится что задача выполнена. Не просто «ответил» — а проверил.

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

5 — Команда. Агенты общаются между собой. Нужна гораздо реже чем кажется.

6 — /workflow. TypeScript код запускает агентов пачками. Версионируется, передаётся, улучшается.

Большинство задач — уровни 1–3.
Главная ошибка: строить команду там где достаточно написать skill.md.

Воскресный лонгрид: https://vc.ru/ai/2967474-kak-izbezhat-degradatsii-konteksta-ai-agenta

Почему AI-native компании следующего десятилетия будут сервисными

YC выпустил про это видео. Посмотрел, и поймал себя на странном ощущении: я узнал в описании то, что строю прямо сейчас.

Ключевой сдвиг там такой.

Обычный SaaS продаёт инструмент. Купи Salesforce, работай в нём сам. AI-native service company забирает работу на себя и продаёт клиенту готовый выход: обработанный страховой случай, готовую декларацию, разобранный договор.

Клиент в интерфейс не заходит. Получает результат.

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

Что зацепило сильнее всего: продукт и операция здесь одно и то же.

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

YC называет это AI operating leverage. Обычный сервисный бизнес упирается в 30% маржи. Ставка: 50%+ на рынках, которые в 2-3 раза больше, чем весь SaaS.

Я не планировал строить AI-native service company. Но когда смотрел видео, понял: это описание того, что происходит у нас.

Интересно, у кого ещё так же?