Несколько недель назад я в очередной раз смотрел видео про нейробиологию — из тех, что начинаешь в 23:00 «на пять минут» и заканчиваешь в два ночи с блокнотом, исписанным стрелками и вопросами. На этот раз это был разбор идей Рэя Курцвейла о том, как устроен человеческий неокортекс.
Я делаю Доку — локальный AI-агент для Windows и Mac, который работает полностью оффлайн, без подписки и без VPN. За несколько месяцев разработки я прошёл стандартный путь: сначала думал, что главное — взять модель помощнее. Потом — что главное хорошо написать системный промпт. Потом — что нужно больше инструментов.
Но пока я слушал про 300 миллионов иерархических модулей неокортекса, про то, что мозг — это не вычислительная машина, а машина предсказаний и ассоциаций, меня накрыло неловкое осознание. Я строил агента неправильно. Не в смысле «плохо» — он работал. Но неправильно в смысле фундаментальной архитектурной ошибки.
Модель — это нейроны. Они важны, но не это делает мозг умным. Умным его делает то, как он хранит, связывает и извлекает опыт.
Что такое Дока и зачем я вообще её делаю
Коротко, для тех кто не знает: Дока — это десктопное приложение. Скачиваешь, устанавливаешь, запускаешь. Никакого Ollama, никакого Python, никакого «откройте терминал». Внутри — локальная языковая модель (Qwen3.5), которая умеет искать в интернете, читать и редактировать файлы на твоём компьютере, выполнять команды в терминале. Попробовать можно на dokaai.ru.
Работает на Windows и Mac. Полностью оффлайн. Данные не покидают устройство. Бесплатно навсегда.
Сейчас у Доки около 5000 скачиваний, и я активно работаю над тем, чтобы она думала лучше — не за счёт более крупной модели, а за счёт архитектуры.
Собственно, об этом и статья.
Главное откровение: мозг не вычисляет — он предсказывает и помнит
Курцвейл описывает неокортекс так: это 300 миллионов иерархически организованных модулей, каждый из которых умеет делать ровно одно — распознавать паттерн на своём уровне абстракции. Нижние модули видят линии и углы. Средние — буквы и формы. Верхние — понятия, эмоции, смыслы.
Но самое важное не иерархия сама по себе. Важно то, как информация в ней движется.
Снизу вверх — это восприятие: «вот что я вижу». Сверху вниз — это предсказание: «вот что я ожидаю увидеть». Когда ты читаешь слово «АНАНАС», твой мозг ещё на уровне первой буквы уже рассылает вниз сигналы готовности: «скорее всего будет «Н», потом «А»». Именно поэтому мы понимаем текст с опечатками и узнаём знакомое лицо при плохом освещении.
Мозг — это не машина, которая ждёт данных. Это машина, которая постоянно генерирует гипотезы и проверяет их реальностью.
А теперь посмотрим на типичный AI-агент. Пользователь написал «прочитай файл config.ts и объясни как работает роутинг».
Агент:
1. Читает сообщение
2. Вызывает LLM
3. LLM решает позвать read_file
4. Файл читается
5. LLM снова вызывается, уже с содержимым
Два полных round-trip к модели только для того, чтобы прочитать файл, который пользователь явно указал в сообщении. Никакого предсказания. Никакой предзагрузки. Просто реактивное ожидание.
То, что я уже успел сделать правильно (немного)
Прежде чем перейти к тому, что менял после просмотра видео, — честный список того, что в Доке уже было сделано в правильном направлении, просто без понимания почему.
Память бесед. После каждого разговора агент автоматически создаёт краткое резюме и сохраняет его. При следующем запуске последние несколько резюме попадают в системный промпт. Агент помнит, что мы обсуждали неделю назад — не потому что «умный», а потому что архитектурно у него есть доступ к этой информации.
Явная память о пользователе. Отдельный файл фактов, которые пользователь хочет чтобы агент помнил всегда. «Я работаю на TypeScript», «не предлагай решения с Docker», «меня зовут Илья». Каждый запрос — эти факты в промпте.
Хранилище результатов инструментов. Когда агент прочитал большую веб-страницу или файл, сырой результат уходит на диск, а в контекст попадает только краткое превью. Если модели нужен полный текст — она запрашивает его явно. Это принципиально важно: контекстное окно не захламляется тем, что не нужно прямо сейчас.
Guardrails. Жёсткие ограничения в коде: не более 20 шагов, не более 3 подряд вызовов одного инструмента, детектор зацикливания. Агент физически не может войти в бесконечный цикл.
Checkpoint и resume. Если что-то пошло не так — агент сохраняет состояние после каждого шага. При следующем запуске можно продолжить с того места, где остановились.
Это всё хорошо. Но после видео я понял, что это только начало.
Что мозг делает, чего мой агент не делал
Тормозящие нейроны
В мозге есть два типа нейронов: возбуждающие и тормозящие. Вторые — не менее важны. Когда ты видишь мужчину с густыми усами, твой мозг мгновенно повышает порог для паттерна «жена» — вероятность близится к нулю. Тормозящие нейроны экономят ресурсы и убирают ложные сигналы.
Мои guardrails были реактивными. Агент уже принял решение «позвоню web_search», уже потратил токены на обдумывание — и только тогда система блокировала лишний вызов. Лошадь ушла из конюшни, а я закрыл ворота.
Правильно — наоборот. Нужно до обращения к модели добавлять в промпт динамические запреты на основе уже выполненных действий: «файл уже прочитан — не ищи его в интернете», «два поиска уже есть — синтезируй из них», «файл только что записан — задача выполнена, не продолжай». Не блокировать постфактум, а повышать порог заранее.
Предсказание сверху вниз
Пока модель думает над первым шагом, можно уже начать загружать то, что точно понадобится. Пользователь написал «прочитай файл server/agent/agent-loop.ts» — зачем ждать пока модель сделает вывод что надо читать именно этот файл? Параллельно с первым LLM-вызовом — уже начинать читать.
Это не оптимизация ради оптимизации. Это архитектурный принцип: агент должен работать на опережение, а не реагировать.
Инвариантность к шуму
Мозг понимает «вседа» вместо «всегда» — потому что усвоил само правило искажения. Он не ломается от опечаток, плохого освещения, акцента. Мой агент регулярно получал в ответ от web_read тонны HTML-мусора — навигации, футеры, рекламные блоки — и тратил на них токены и внимание модели. Или получал HTTP 403 и просто сообщал об ошибке, хотя мог бы предложить альтернативу.
Нужен промежуточный слой нормализации: прежде чем результат инструмента попадёт к модели — очистить шум, преобразовать ошибки в понятные инструкции, отфильтровать бессмысленные данные.
Память как граф, а не список
Мозг хранит не факты — он хранит связи между фактами. «Лимон» активирует «жёлтый», «кислый», «чай», «Италия», «витамин C» одновременно. Память без связей — это потерянные страницы в интернете без входящих ссылок. Найти невозможно.
У меня в Доке память — это список резюме и список фактов. Плоская структура. Нет связей между «пользователь работает над проектом Дока» и «агент-луп находится в server/agent/agent-loop.ts». Эти вещи связаны — но агент не знает об этой связи, пока не прочитает оба факта в одном контексте.
Конфабуляция
Газзаниги проводил эксперименты с пациентами с расщеплённым мозгом. Правое полушарие держало лопату, потому что видело снег. Левое — не знало об этом, но когда его спросили «зачем лопата?» — мгновенно выдало объяснение: «чтобы убирать в курятнике». И искренне верило в эту ложь.
Агенты конфабулируют точно так же. «Файл создан» — а write_file не вызывался. «Я нашёл информацию» — а в tool outputs её нет, это была галлюцинация. Модель не лжёт намеренно — она просто заполняет пробелы наиболее правдоподобным текстом. Детектировать это программно вполне реально: сравнить утверждения в ответе с тем, что реально вернули инструменты.
Главный тезис, который я наконец сформулировал
После всего этого я написал себе одну фразу и повесил её над монитором:
Мощность модели — это нейроны. Умным агента делают память, инструменты и архитектура их взаимодействия.
Qwen3.5 на 9B параметров с хорошей памятью, правильными инструментами и умной оркестрацией обыграет ChatGPT в «глупом» агентском цикле. Не потому что она лучше. А потому что умный агент — это не про токены в секунду. Это про то, сколько релевантного контекста попадает в модель в нужный момент, и насколько точно агент понимает что делать дальше.
Локальный агент имеет уникальное преимущество: он работает с твоими файлами, знает твои проекты, помнит твои предпочтения. Это и есть персональная память — то, чего у облачных агентов нет по определению.
Что я теперь строю
Часть идей уже в работе, часть — в планах. Без кода, только концептуально.
Проактивные запреты. На каждом шаге агентского цикла — анализировать что уже сделано и добавлять в промпт конкретные ограничения. Динамический, контекстно-зависимый слой, который работает как тормозящие нейроны — снижает вероятность лишних действий ещё до того, как модель их придумает.
Предзагрузка. Прежде чем первый раз обращаться к модели — параллельно читать файлы и URL, явно упомянутые пользователем. Если модель потом попросит то же самое — результат уже готов.
Нормализация результатов. Промежуточный слой между инструментом и моделью: убрать HTML-мусор, преобразовать ошибки в осмысленные инструкции, распознать бинарный файл до того, как он засорит контекст.
Затухание памяти. Факты, к которым давно не обращались, должны постепенно «тускнеть» и в конечном счёте удаляться. Память не должна расти бесконечно — она должна быть живой. Часто нужные факты остаются, редкие исчезают.
Детектор конфабуляций. После финального ответа — автоматически проверять: агент написал «файл сохранён» — а был ли реальный вызов на запись? Привёл конкретное число — а есть ли оно в результатах инструментов? Предупреждение прямо в интерфейсе.
Вето. Новый инструмент — не для поиска или чтения, а для метауровня. Агент может явно сказать «я не буду этого делать, потому что это приведёт к зацикливанию — вот что я предлагаю вместо». Лучше, чем молча повторять одно и то же до срабатывания автоматического детектора цикла.
Составные инструменты. Поверх примитивных — высокоуровневые: «исследуй тему» (поиск + чтение + извлечение фактов за один шаг), «найди и исправь» (поиск по файлам + чтение + правка). Агент сам выбирает, использовать ли примитив с точным контролем или составной для экономии шагов.
LLM Wiki (главная фича). Самообновляющаяся база знаний в виде обычных markdown-файлов. Агент сам дополняет её из разговоров, сам исправляет устаревшее, сам по ней отвечает. Никакого vector store, никаких эмбеддингов — просто файлы с перекрёстными ссылками. Паттерн Карпати, который набрал 5000 звёзд на GitHub в первые дни.
Почему это важно именно для локального агента
Облачный агент знает тебя ровно столько, сколько ты написал в этой сессии. Он не помнит разговор месячной давности. Он не знает, что в твоём проекте принято называть файлы именно так. Он не знает что ты уже пробовал это три раза и каждый раз бросал на середине.
Локальный агент может знать всё это — если архитектура памяти правильная. У него нет ограничений по хранению. Он не тарифицирует токены памяти. Он живёт на твоём компьютере и может накапливать контекст месяцами.
Это и есть настоящее конкурентное преимущество. Не «работает без интернета» (хотя это тоже важно). А «становится умнее именно для тебя» — со временем, постепенно, без лишних действий с твоей стороны.
Что в итоге
Я не стал умнее после просмотра видео про нейробиологию. Но у меня появился язык для описания проблем, которые я интуитивно чувствовал, и конкретные направления для решений.
Мозг умный не потому что нейроны быстрые. Они, кстати, медленные — около 200 Гц против гигагерц у процессора. Мозг умный потому что 300 миллионов модулей правильно организованы, правильно связаны и правильно взаимодействуют.
AI-агент умный не потому что модель большая. Он умный потому что помнит нужное, игнорирует лишнее, предсказывает следующий шаг и честно говорит когда не знает.
Именно это я и строю.
Дока — локальный AI-агент для Windows и Mac. Работает оффлайн, без подписки, без VPN. Скачать и попробовать можно на dokaai.ru. История разработки — в моём профиле.
ссылка на оригинал статьи https://habr.com/ru/articles/1030856/