AI summary сегодняшней встречи, где рассказываю про GenAI

Три кита, на которых стоит любой агент

Когда мы говорим про любого агента — будь то ChatGPT, GitHub Copilot или какая-то кастомная система — ему нужно дать три ключевых компонента.

Глаза: как агент видит мир

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

Примеры:

• Видеоролик → транскрипция даёт доступ к тексту
• Miro-борд → нужна возможность увидеть структуру диаграммы, а не просто набор квадратиков
• Excel на SharePoint → агент должен уметь открыть таблицу по ссылке и прочитать данные

Руки: как агент влияет на мир

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

Примеры:

• Создание видео с аватаром → нужен инструмент для обращения к сервису генерации видео
• Построение диаграммы в Miro → нужен плагин для доступа к борду
• Редактирование Excel → нужны права на изменение файла в конкретном месте

Память: зачем агент всё это делает

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

В агентных системах типа GitHub Copilot вы просто создаёте markdown-файл с инструкцией, где описываете:

• Что вы хотите делать и зачем
• Как пользоваться "глазами" и "руками"
• Какой результат должен получиться

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

Инструкции: живой документ, который растёт вместе с вами

Один раз создали — используем всегда

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

Итеративное улучшение

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

"Давай исправим инструкцию так, чтобы этой проблемы больше никогда не было"

Например, агент начал отвечать на русском, а вам нужен английский. Попросите:

"Дополни инструкцию: все артефакты на английском, диалог — на языке пользователя"

Агент обновит инструкцию, и в следующей сессии всё будет работать правильно. Это как версионирование вашего рабочего процесса.

Практика: автоматизация работы с митинг-транскрипциями

Проблема

Митинги занимают 60-70% рабочего времени. После каждого нужно сделать follow-up с участниками. Представьте: вышли с митинга — и сразу получили нужный output на основе транскрипции.

Решение

Копируете файл транскрипции из Teams в свою рабочую папку. Там уже лежит инструкция, которая описывает, как обработать эту транскрипцию и какой output вы хотите получить.

В отличие от ChatGPT, где сложно менять промпт после того, как вы его написали, здесь у вас есть полный контроль:

1. Запустили обработку транскрипции
2. Увидели что-то не то
3. Попросили исправить инструкцию
4. В следующий раз всё работает как надо

Следующий уровень

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

Под капотом: что происходит на самом деле

Контекстное окно

Когда вы общаетесь с агентом, под капотом уходит огромное количество информации, которую вы не видите:

• Системный промпт от Copilot
• Перечень доступных инструментов
• Содержимое вашей папки
• Информация о пользователе (время, расположение)
• Список всех инструментов

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

Цепочка действий

Вот как это работает:

1. Модель видит файл с инструкциями
2. Принимает решение: "Хочу прочитать файл с библиотеками"
3. Вызывает инструмент read_file
4. Агент физически читает файл
5. Результат добавляется в контекст
6. Модель анализирует и даёт вам ответ

Всё это происходит за кулисами. Но именно это даёт такую мощь.

Вопросы безопасности

Нужно чётко понимать три слоя защиты:

1. Корпоративный аккаунт — используйте учётку, зарегистрированную в вашей компании
2. Разрешённая модель — убедитесь, что можете пользоваться конкретной моделью
3. Здравый смысл — не сливайте критически важные данные

Много информации уходит под капотом — это факт. Поэтому выбирайте проверенные инструменты и корпоративные аккаунты.

Канва повествования: кто на самом деле пишет текст

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

Четыре писателя

1. Вы (пользователь)
Вы печатаете свой запрос: "Прочитай файл library_analysis.md и сделай краткое резюме". Это видно в чате.

2. Агентная система (Copilot)
Она добавляет на канву то, чего вы не видите:

• Системный промпт с контекстом
• Список доступных инструментов (tools)
• Содержимое вашей рабочей папки
• Информацию о вашем окружении
• Инструкции из файлов

3. LLM (языковая модель)
Модель видит всё, что напечатали вы и агентная система. И она тоже печатает на этой канве, но не только текст для вас. Она печатает команды:

Я хочу вызвать инструмент: read_file
Параметры: filePath="library_analysis.md"

4. Tools (инструменты)
Агентная система видит, что модель напечатала вызов инструмента. Она физически выполняет действие (читает файл) и печатает результат обратно на канву:

Содержимое файла library_analysis.md:
[весь текст файла]

Как это работает на практике

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

Вы видите:

Вы: Проанализируй библиотеки в проекте
Copilot: Сейчас прочитаю список библиотек... 
         Вот что я нашёл: используется requests, pandas, numpy...

На канве повествования происходит:

[Системный промпт от Copilot]
Вы эксперт по анализу кода. Список доступных инструментов:
- read_file(filePath)
- list_dir(path)
- grep_search(query)
[...]

[Содержимое папки проекта]
/project
  /src
    main.py
    utils.py
  requirements.txt
  README.md

[Ваше сообщение]
Пользователь: Проанализируй библиотеки в проекте

[Модель думает и печатает]
LLM: Хочу прочитать файл requirements.txt
     Команда: read_file("requirements.txt")

[Агентная система выполняет и печатает результат]
Tool: Содержимое requirements.txt:
      requests==2.28.0
      pandas==1.5.0
      numpy==1.23.0

[Модель видит результат и печатает ответ пользователю]
LLM: Сейчас прочитаю список библиотек...
     Вот что я нашёл: используется requests, pandas, numpy...

Почему это важно понимать

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

1. Модель не выполняет действия сама — она только печатает на канве, что хочет вызвать инструмент
2. Агентная система — дирижёр — она видит эти команды и выполняет их физически
3. Результаты возвращаются на канву — модель их видит и может принимать следующие решения
4. Цикл повторяется — модель может вызывать инструменты десятки раз, пока не получит всё необходимое

Метафора театра

Вы сидите в зале и видите актёра на сцене (модель), который вам что-то рассказывает. Но за кулисами:

• Есть суфлёр (агентная система), который подсказывает контекст
• Есть реквизиторы (tools), которые по команде приносят нужные предметы
• Всё это записывается на огромный свиток (канва повествования)

Когда актёр говорит: "Мне нужен меч" — он не сам идёт за мечом. Он произносит реплику, реквизитор слышит, приносит меч, кладёт на сцену, и актёр продолжает игру. Зрители (вы) этого не видят — для них меч появился как будто сам собой.

Практический смысл

Понимание этой архитектуры меняет то, как вы работаете с агентами:

• Модель не всесильна — она может только просить что-то сделать из списка доступных инструментов
• Чем лучше инструменты — тем больше модель может сделать
• Промпты — это сценарий — вы пишете не только для модели, но и даёте контекст всей системе
• Большая часть магии скрыта — между вашими сообщениями может происходить десятки вызовов инструментов

Когда вы просите "создай проект на TypeScript", модель не пишет код сама. Она вызывает:

• create_directory("project")
• create_file("package.json", content=...)
• create_file("tsconfig.json", content=...)
• create_file("src/index.ts", content=...)

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

RAG: когда данных слишком много

Проблема контекстного окна

Представьте: у вас 100 файлов по 30 страниц каждый. Всё это не влезет в контекстное окно модели. Но вам нужно, чтобы агент мог искать информацию во всех этих документах.

Как работает RAG

RAG (Retrieval Augmented Generation) — технология, которая решает эту проблему:

1. Разбивка на чанки — текст делится на небольшие фрагменты
2. Векторная база данных — чанки сохраняются в специальную БД
3. Семантический поиск — когда вы делаете запрос, система ищет не по ключевым словам, а по смыслу
4. Контекстная выборка — в промпт попадают только те чанки, которые на 80%+ релевантны вашему запросу
5. Генерация ответа — модель отвечает на ваш вопрос на основе найденных фрагментов

Практическое применение

Можно загрузить туда всю документацию из Confluence, все спецификации проекта, все митинг-ноуты — и агент сможет отвечать на вопросы по всему этому массиву данных.

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

Чёрный ящик: программирование без программирования

Революция порога входа

Сейчас порог входа в программирование практически исчез. У меня был проект, где нужно было написать MVP. Я даже не знал, на каком языке он пишется — и мне было всё равно. Я просто описывал архитектуру и задачи. Только потом выяснилось, что это TypeScript.

Принцип работы с чёрным ящиком

1. Вход → вы даёте агенту что-то на вход
2. Процесс → внутри чёрный ящик, вы не видите код
3. Выход → смотрите на результат
4. Обратная связь → если результат не тот — даёте фидбек

"Вернулось не то, что я ожидал. Исправь так, чтобы в следующий раз возвращало правильный результат"

Агент идёт, исправляет, и в следующий раз всё работает.

Высокоуровневые требования

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

"Нужно, чтобы на выходе было с перламутровыми пуговицами"

Таким образом, не умея программировать, вы можете управлять процессом через обратную связь.

Выбор инструментов

Какую модель использовать?

Есть разные модели, каждая специализируется на чём-то своём. На основе всего опыта 2024-2025 года могу рекомендовать:

Claude Sonnet 4 или 4.5 — лучшая модель из того, что сейчас есть на рынке:

• Отлично кодит
• Работает в агентном режиме
• Рефлексирует над результатами
• Хорошо работает с файлами
• Качественно обрабатывает текст

GPT-5 для поболтать, но Claude Sonnet проверена на практике и показывает стабильные результаты.

Создание скриптов и скиллов

Автоматизация через скрипты

В процессе работы вы просите агента:

"Давай сделаем скрипт, который превращает текст в видеоролик"

Немного работы с агентом — и у вас есть готовый скрипт. Агент может использовать его как инструмент в будущем.

Накопление навыков

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

• Вроде что-то накодировали
• Но внутрь заглянуть не можете
• Зато можете проверять вход/выход
• И давать обратную связь для улучшения

Не умея программировать, вы создаёте рабочие инструменты.

Автоматизация бизнес-процессов

Принцип приоритизации

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

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

С чего начать

1. Найдите самую большую рутину — то, что отнимает больше всего времени
2. Посмотрите на соседей — если процесс одинаковый в нескольких командах, можно масштабировать решение
3. Начните с простого — автоматизация без "рук", только обработка текста
4. Постепенно добавляйте интеграции — OneDrive, Notion, Confluence

Система инструкций

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

Подложили файл, сказали "фас" — и агент знает, что с ним делать. Создаёт нужные артефакты и отправляет их куда нужно.

Как это выглядит в реальности

Центр управления

У вас локально будет:

• Проект с вашими агентами
• Папка work для рабочих файлов
• Чат-сессия для команд агенту

Рабочий процесс

Вы: "Только что был митинг, файл называется meeting_2026-01-22.vtt. 
     Определи тип митинга и сделай всё что надо"
     
[Агент обрабатывает транскрипцию]
[Создаёт артефакты]
[Раскладывает по нужным папкам]
[Отправляет follow-up участникам]

Вы: "Готово? Супер."

Развитие системы

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

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

"Есть сайт. Нужен скрипт, который достаёт оттуда максимум информации и печатает в консоль"

Агент пишет скрипт, потом читает его вывод и делает выводы.

Заключение

GenAI-агенты — это не магия, а инструмент. Как любой инструмент, его нужно настроить под себя. Но когда он настроен — появляется ощущение, что у вас есть ассистент, который:

• Помнит ваши предпочтения
• Учится на ошибках
• Не устаёт от рутины
• Работает по чётким инструкциям

Начните с малого: автоматизируйте одну рутинную задачу. Посмотрите, как это работает. Улучшите инструкцию. И двигайтесь дальше.

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