Как создать AI-агента с нуля в 2026: пошаговый гайд по AI Agents From Scratch

Гайд: AI Agents From Scratch 2026 — собрать AI-агента с нуля за 14 шагов

Большинство туториалов по AI-агентам учат тому, как вызвать LangChain. Один проект на GitHub решил сделать наоборот — вскрыть агента и показать, что внутри. Никаких фреймворков, никаких облаков, никакой магии.

AI Agents From Scratch — это open-source репозиторий с 4030 звёздами, который строит агента с нуля: от первого вызова LLM до полноценного ReAct-цикла и AoT-планировщика. Доступен на JavaScript и Python, MIT-лицензия, запускается локально.

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

Что такое AI Agents From Scratch и в чём суть подхода

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

Именно второй путь выбрал автор репо под ником @pguso. Запустил проект в октябре 2025 года — и без маркетинга, без вирального поста, чисто на качестве контента собрал 4030 звёзд на JS-версии и ещё 794 на Python.

Философия проекта держится на трёх принципах:

• Агенты — это не личности. Это циклы, состояние и ограничения
• Если что-то выглядит как магия — открой файл. Скрытой логики здесь нет
• Структура надёжнее, чем умные промпты

Именно поэтому репо называют «анти-LangChain». Не потому что плохо к нему относится, а потому что сначала учит понимать, потом использовать.

Шаг 0. Подготовка: выбери стек и проверь железо

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

JS или Python?

Если пишешь на JS/Node — берёшь JS-версию. Если на Python — Python. Философия одинаковая, путь немного отличается. JS-версия активнее обновляется, Python появился позже, но закрывает тот же материал.

Требования к железу

Проект работает полностью локально. Модели скачиваются в формате GGUF и запускаются на твоей машине.

• Node.js 18+ (для JS) или Python 3.10+
• RAM: минимум 8 GB, рекомендовано 16 GB
• Диск: 2–4 GB на модель

Если 16 GB нет — берёшь модель 7B вместо 13B. Чуть медленнее, но работает. На 8 GB вполне реально пройти все уроки с Llama 7B в GGUF-квантизации.

Установка

# JS-версия
git clone https://github.com/pguso/ai-agents-from-scratch
cd ai-agents-from-scratch
npm install
# скачать GGUF-модель в ./models/
node intro/intro.js

# Python-версия
git clone https://github.com/pguso/agents-from-scratch
cd agents-from-scratch
pip install -r requirements.txt
# скачать GGUF-модель в models/
python complete_example.py

Рекомендуемые модели для старта: Llama 3.1 8B или Mistral 7B в GGUF-формате. Скачать можно с Hugging Face в разделе GGUF-quantized models.

Шаг 1. Блок Foundation: как вообще работает LLM (уроки 1–3)

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

Урок 1: Basic LLM

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

Что понимаешь после: токен — это не слово. Это кусок текста (обычно 3–4 символа). Контекстное окно — это максимум токенов, которые модель видит за раз. Всё, что не влезает в контекст, модель не знает.

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

Урок 2: OpenAI Intro (опциональный)

Тот же принцип, но через облачный API. Показывает разницу между локальным запуском и vendor-зависимостью: rate limits, стоимость токенов, latency.

Этот урок опциональный — можешь пропустить, если хочешь остаться полностью local-first.

Урок 3: System Prompts и специализация агента

Здесь впервые появляется концепция специализации. Один и тот же LLM с разными системными промптами ведёт себя как разные агенты: переводчик, кодер, аналитик.

// Агент-переводчик
const systemPrompt = "You are a professional translator. Translate all user messages to Russian. Return only the translation, no explanations.";

Что понимаешь после: агент — это не отдельная модель. Это поведенческие ограничения через системный промпт плюс логика вокруг LLM.

Шаг 2. Блок Agency: инструменты, решения, первый цикл (уроки 4–7)

Это самый важный блок. Здесь происходит переход от «модель генерирует текст» к «агент принимает решения и действует».

Урок 4: Reasoning — логическое рассуждение

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

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

Урок 5: Batch Processing

Параллельная обработка нескольких промптов одновременно. Для вайбкодера это актуально когда нужно обработать массив данных: 100 карточек товаров, 50 постов, набор документов.

Урок 6: Streaming

Стриминг токен за токеном — как работает «печатающий» ответ в ChatGPT. После этого урока понимаешь, как реализовать такое в своём приложении и почему streaming улучшает UX лучше, чем ждать полного ответа.

Урок 7: Function Calling — ключевой момент

Это точка перехода от LLM к агенту. Function calling — механизм, при котором модель сама решает, когда вызвать внешнюю функцию и с какими аргументами.

Работает через JSON Schema. Ты описываешь функции:

const tools = [
  {
    name: "get_weather",
    description: "Get current weather for a location",
    parameters: {
      type: "object",
      properties: {
        location: { type: "string", description: "City name" }
      },
      required: ["location"]
    }
  }
];

Модель читает описания, анализирует запрос пользователя и сама решает: вызвать функцию или ответить текстом. Никакой магии — это парсинг JSON Schema плюс решение на уровне attention механизма.

Что понимаешь после: Claude Code, Cursor, любой современный AI-ассистент — все работают через function calling. Ты видишь это изнутри впервые.

Шаг 3. Блок Intelligence: память, ReAct и атомарное планирование (уроки 8–10)

Три урока, после которых агенты перестают быть магией полностью.

Урок 8: Memory Agent — персистентное состояние

Без памяти каждый новый запрос для агента — первый. Урок показывает два типа памяти:

• Краткосрочная (in-context) — история диалога в контекстном окне. Дёшево, быстро, ограничена размером контекста
• Долгосрочная (external) — факты и итоги сохраняются во внешнем хранилище, подгружаются при нужде

Как это работает на практике: агент заканчивает задачу, извлекает ключевые факты («пользователь предпочитает TypeScript», «проект использует Postgres»), сохраняет в JSON или БД. При следующем запуске загружает релевантное в контекст.

Для вайбкодинга: любой бот с «памятью» о пользователе работает по этой схеме. Понимаешь механику — строишь сам без магических библиотек.

Урок 9: ReAct Agent — фундамент всех современных агентов

ReAct (Reasoning + Acting) — это паттерн, на котором строятся Claude Code, большинство LangChain агентов и вообще всё агентное в 2026 году.

Цикл простой:

Задача
  → Reason: «мне нужно проверить погоду в Москве»
  → Act: вызвать get_weather("Москва")
  → Observe: {"temp": 12, "condition": "облачно"}
  → Reason: «теперь могу ответить пользователю»
  → Ответ

Агент повторяет цикл до тех пор, пока не решит задачу или не упрётся в лимит итераций. Именно так работает агент, когда пишет код, запускает тест, видит ошибку, исправляет, запускает снова.

Что понимаешь после: когда Claude Code «думает» и делает несколько действий подряд — это ReAct loop. Ты видел его изнутри, можешь строить такой же.

Урок 10: AoT Agent — «SQL для рассуждений»

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

Atom of Thought (AoT) решает это по-другому. Агент сначала создаёт JSON-план из атомов, каждый атом — одно действие с зависимостями:

{
  "atoms": [
    { "id": 1, "name": "fetch_prices", "input": {"source": "api"}, "dependsOn": [] },
    { "id": 2, "name": "calculate_margin", "input": {}, "dependsOn": [1] },
    { "id": 3, "name": "generate_report", "input": {}, "dependsOn": [2] }
  ]
}

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

Максим: «Когда мы строили автоматизацию для GoBanana, главная боль была — агент делал что-то непонятное, и ты не мог понять, где сломалось. AoT решает именно это: видишь граф, видишь где упало, перезапускаешь с нужного атома. На боевых воркфлоу разница колоссальная.»

Шаг 4. Блок Advanced Reasoning: три способа думать (уроки 11–14)

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

Урок 11: Error Handling

Не паттерн рассуждений — критическая инженерная тема. Агент в продакшене падает. Вопрос не «если», а «когда».

Что разбирается:

• Типизированные ошибки (не просто catch(e), а конкретные классы ошибок)
• Timeout — сколько ждать ответа от LLM или инструмента
• Retry с exponential backoff и jitter — как переповторять без DDoS
• Graceful degradation — что делать, если инструмент недоступен

Для вайбкодера это про разницу между демо и продуктом. Демо падает — ок. Продукт на 200 000 пользователей падает с деньгами внутри — нет.

Урок 12: Tree of Thought

Обычный агент — один путь рассуждений. Tree of Thought генерирует несколько кандидатных веток из одной точки, оценивает каждую и выбирает лучшую.

Задача: «какую архитектуру выбрать?»
  ├── Ветка A: микросервисы → оценка: сложно для MVP, плюс: масштабируемость
  ├── Ветка B: монолит → оценка: просто, минус: сложнее позже
  └── Ветка C: модульный монолит → оценка: компромисс, рекомендуется

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

Урок 13: Graph of Thought

GoT — это DAG-оркестрация для задач с несколькими источниками. Вместо последовательного обхода — параллельное извлечение, потом слияние по правилам.

Ключевая фича: конфликты разрешаются ДО генерации финального вывода. В коде это выглядит через поля must_include, must_avoid, conflict_notes. Пример задачи: собрать обзор инструмента из десяти источников без внутренних противоречий.

Когда что брать:

Урок 14: Chain of Thought

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

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

Шаг 5. Python-версия: один агент, 12 эволюций

Python-репо устроено иначе, чем JS. Здесь один и тот же файл agent.py растёт от урока к уроку — никаких новых файлов «с нуля».

Это важная педагогическая разница. Ты не просто изучаешь новый паттерн — ты видишь, как он встраивается в уже существующую архитектуру.

Блок Observability (уроки 11–12) — часть, которую обычно игнорируют в туториалах. Здесь: evaluation framework для регрессионного тестирования агента и телеметрия для отслеживания поведения в runtime.

Без этого ты не знаешь, стал ли агент лучше после изменений. С этим — знаешь.

Шаг 6. Фаза 2 — воссоздать LangChain с нуля

После Фазы 1 начинается кое-что другое. Фаза 2 — воссоздание LangChain и LangGraph с нуля. Не чтобы сделать новый фреймворк, а чтобы понять, как устроен старый.

Что перестраивается и почему это важно

Структура туториала Фазы 2:

tutorial/
├── 01-foundation/
│   ├── 01-runnable/        # Паттерн Runnable
│   ├── 02-messages/        # Типизированные сообщения
│   ├── 03-llm-wrapper/     # Абстракция над моделью
│   └── 04-context/         # Управление состоянием диалога
├── 02-composition/
│   ├── 01-prompt-template/ # Переиспользуемые промпты
│   ├── 02-output-parser/   # Структурированный вывод
│   ├── 03-llm-chain/       # LLMChain
│   ├── 04-piping/          # Композиция Runnables
│   └── 05-memory/          # Контекстная память
└── 03-agents/              # Coming Soon

Раздел Agents в Фазе 2 ещё в разработке — помечен «Coming Soon». Foundation и Composition уже готовы. Этого хватает, чтобы понять 80% того, почему LangChain устроен именно так.

Сильные стороны и честные ограничения

Что репо делает хорошо

• Тройная документация на каждый урок: код + построчное объяснение + концептуальный разбор. Редкость для open-source
• Local-first: никаких API-ключей по умолчанию, полный контроль, никаких rate limits
• AoT как уникальная фича: нигде больше такого подробного разбора «SQL для рассуждений» нет
• Два стека: JS и Python — выбирай свой
• MIT-лицензия: делай что хочешь, в том числе в коммерческих проектах
• Solo-проект с авторским голосом: нет корпоративной размытости и «безопасных» формулировок

Честные ограничения

• Solo-мейнтейнер: bus factor = 1. Для обучения не страшно, для продакшен-зависимости — стоит помнить
• Не production-гайд: репо сам предупреждает — это про фундаменты, не про best practices
• Фаза 2 не завершена: раздел Agents ещё «Coming Soon»
• RAM: меньше 8 GB — будет сложно. Меньше 16 GB — придётся брать меньшие модели
• JS-версия активнее Python: если нужен самый свежий контент — JS

Кому проходить, а кому пока нет

Репо честно говорит о своей аудитории. Лучше сразу понять, попадаешь ли ты в неё.

Для тебя, если:

• Уже умеешь запускать агентов через готовые инструменты — Cursor, Claude Code, LangChain — но не понимаешь, что происходит внутри
• Строишь AI-продукты и хочешь принимать архитектурные решения осознанно, а не наугад
• Хочешь локальные модели без зависимости от OpenAI или Anthropic API
• Планируешь разобраться с LangChain/LangGraph на уровне кода, а не только доки

Не для тебя, если:

• Нужен прототип сегодня — тогда берёшь готовый фреймворк и не тратишь время
• Ищешь production-готовый шаблон с best practices
• Нет хотя бы базовых знаний JS или Python — первые уроки потребуют умения писать код

Смежные ресурсы

Кроме основного репо у автора есть два сопутствующих ресурса.

Python-версия — github.com/pguso/agents-from-scratch: 794 звезды, 200 форков, 12 уроков. Та же философия на Python. Создана в декабре 2025, чуть отстаёт от JS по активности.

Сайт-компаньон — agentsfromscratch.com: не замена коду, а дополнение. Объясняет почему каждый пример существует, визуализирует learning path, помогает строить ментальные модели перед погружением в код.

Рекомендуемый воркфлоу: сайт — для ментальных моделей и понимания «зачем». GitHub — для запуска, чтения и модификации кода.

Глоссарий

LLM (Large Language Model) — большая языковая модель. Нейронная сеть, которая принимает текст и генерирует текст. Примеры: Claude, GPT-4, Llama.

Токен — единица обработки текста в LLM. Обычно 3–4 символа или одно слово. Контекстное окно измеряется в токенах.

Agent loop — цикл агента: получить задачу → выбрать действие → выполнить → наблюдать результат → повторить до достижения цели или лимита итераций.

Function calling — механизм, при котором LLM анализирует JSON Schema доступных функций и сама решает, когда вызвать функцию с какими параметрами.

ReAct (Reasoning + Acting) — паттерн: рассуждение → действие → наблюдение результата → снова рассуждение. Фундамент большинства современных агентных систем.

AoT (Atom of Thought) — подход к планированию через JSON-граф атомарных действий. Каждый атом — одно действие, все атомы образуют DAG с зависимостями.

DAG (Directed Acyclic Graph) — направленный ациклический граф. Структура с направленными связями без циклов. Используется для описания зависимостей между задачами агента.

GGUF — формат хранения весов локальных LLM, оптимизированный для запуска на CPU с квантизацией. Скачивается с Hugging Face.

Tree of Thought (ToT) — паттерн: агент генерирует несколько ветвей рассуждений параллельно, оценивает каждую и выбирает лучшую (beam search).

Graph of Thought (GoT) — паттерн для агрегации нескольких источников через DAG-оркестрацию с явным разрешением конфликтов до генерации финального вывода.

Runnable Interface — паттерн композиции в LangChain. Базовый интерфейс, на котором строятся все цепочки: принимает вход, возвращает выход, может быть соединён с другим Runnable через pipe.

Exponential backoff — стратегия retry: после каждой неудачи ждёшь в два раза дольше, чем в прошлый раз. Предотвращает шквал повторных запросов при падении сервиса.

FAQ

Нужен ли опыт в ML или математике для прохождения?
Нет. Первые уроки объясняют всё с нуля — что такое токены, как работает inference, почему контекст важен. Достаточно умения писать на JS или Python.

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

Какую модель лучше скачать для старта?
Llama 3.1 8B или Mistral 7B в GGUF-квантизации (Q4_K_M достаточно). На 16 GB RAM комфортно. На 8 GB — берёшь Q3 квантизацию, будет медленнее, но работает.

Сколько времени занимает Фаза 1?
При 1–2 часах в день — около двух недель. Каждый урок построен как один сеанс: прочитал концепт, запустил код, поломал, починил, пошёл дальше.

AoT сложнее ReAct? С чего начать?
Начинай с ReAct (урок 9) — он проще и даёт базовое понимание agent loop. AoT (урок 10) — следующий шаг, когда нужна воспроизводимость и явное планирование.

Как подключить Claude или GPT вместо локальной модели?
Урок 2 показывает подключение к облачным API. Любой пример из Фазы 1 можно адаптировать под Claude или OpenAI, просто заменив клиент. Автор намеренно оставил это опциональным.

Есть ли сообщество вокруг проекта?
GitHub Issues и Discussions — пока небольшое, но активное. Проект solo-maintained, поэтому community растёт органически вместе с репо.

С чего начать прямо сейчас

Три шага для старта:

1. Клонируй нужную версию (JS или Python)
2. Скачай GGUF-модель (Llama 3.1 8B Q4_K_M с Hugging Face)
3. Запусти урок 1, потом 7, потом 9 — это минимальный путь к пониманию agent loop

Репозитории:

• JS: github.com/pguso/ai-agents-from-scratch — 4030★
• Python: github.com/pguso/agents-from-scratch — 794★
• Сайт: agentsfromscratch.com

Если хочешь разобраться с агентами глубже — посмотри наш каталог AI-инструментов. Там собраны все среды разработки, с которыми агентные паттерны из этого репо стыкуются лучше всего: Windsurf, Cursor, Claude Code.

Хочешь разобраться, как применить конкретные агентные паттерны в своём продукте — запишись на консультацию к Максиму. Он строил автоматизацию для GoBanana (231 000 пользователей) и знает, что из этого реально работает в продакшене, а что красиво выглядит только в туториалах.

Обновлено: май 2026 | vibecoderz.ru