WEBVTT

00:00:00.000 --> 00:00:05.340
Тема сегодняшнего выпуска – то, о чем слышали почти все, но мало кто может объяснить обвязка и агента.

00:00:05.500 --> 00:00:09.360
Вы наверняка видели это в блогах или на конференциях, но что это означает на самом деле?

00:00:09.580 --> 00:00:13.960
Суть вот в чем. Большинство считает, что создание и агента – это написание идеального промпта,

00:00:14.080 --> 00:00:17.620
той самой магической инструкции, которая заставит модель делать именно то, что нужно.

00:00:17.800 --> 00:00:20.720
Но это все равно, что считать, будто автомобиль – это только двигатель.

00:00:20.840 --> 00:00:25.880
Конечно, двигатель важен, но без колес, руля, тормозов и шасси вы никуда не уедете.

00:00:25.880 --> 00:00:32.520
К концу этого выпуска вы поймете, что такое обвязка агента, почему это следующий этап после промп-инженеринга

00:00:32.520 --> 00:00:36.640
и как Microsoft iPhone 3 воплощает это в жизнь для реального бизнеса.

00:00:37.100 --> 00:00:39.040
Берите кофе и давайте начнем.

00:00:39.160 --> 00:00:40.860
Почему промптов уже недостаточно?

00:00:41.140 --> 00:00:42.100
Вернемся к истокам.

00:00:42.240 --> 00:00:45.700
Примерно с 2022 по 2024 год работать с И было просто.

00:00:45.860 --> 00:00:47.400
Вы писали промп и получали ответ.

00:00:47.600 --> 00:00:48.640
Нужен черновик письма.

00:00:48.820 --> 00:00:49.600
Напишите промп.

00:00:49.780 --> 00:00:51.280
Нужно краткое изложение статьи.

00:00:51.440 --> 00:00:52.360
Напишите промп.

00:00:52.420 --> 00:00:54.540
Для простых разовых задач это работало отлично.

00:00:54.540 --> 00:00:57.440
Вы просили о чем-то, и модель выдавала разумный ответ.

00:00:57.620 --> 00:00:59.300
Но затем аппетиты людей выросли.

00:00:59.440 --> 00:01:01.740
Они стали поручать моделям реальную работу.

00:01:01.940 --> 00:01:05.920
Изучить тему и написать отчет, проанализировать код и исправить баг

00:01:05.920 --> 00:01:09.320
или вести многоэтапный диалог с клиентом от начала до конца.

00:01:09.480 --> 00:01:11.740
И внезапно одного промпта стало не хватать.

00:01:11.920 --> 00:01:12.860
Вот что происходило.

00:01:12.980 --> 00:01:14.680
Контекстное окно модели переполнялось.

00:01:14.880 --> 00:01:19.080
Она забывала начальные инструкции и начинала выдумывать факты или выдавать неполные результаты.

00:01:19.220 --> 00:01:22.460
Чем дольше длилась задача, тем менее надежным становился результат.

00:01:22.460 --> 00:01:24.640
Вы наверняка сами с этим сталкивались.

00:01:24.860 --> 00:01:26.900
Вы просите и сделать что-то сложное.

00:01:27.180 --> 00:01:30.180
А к концу он забывает, о чем вы просили в самом начале.

00:01:30.520 --> 00:01:36.040
Представьте, что вы просите одного человека построить дом с нуля за один присест, не проверяя его работу.

00:01:36.280 --> 00:01:38.240
Именно это мы и требовали от таких моделей.

00:01:38.480 --> 00:01:39.820
Результаты были предсказуемыми.

00:01:40.180 --> 00:01:42.880
Недостроенный дом без стен и с дверями, которые не открываются.

00:01:43.140 --> 00:01:44.980
Решением был не более удачный промп.

00:01:45.080 --> 00:01:49.260
Можно часами оттачивать формулировки, добавлять примеры и уточнять инструкции.

00:01:49.260 --> 00:01:55.620
Но задача все равно провалится, потому что фундаментальная проблема была не в промпте, а в отсутствии системы вокруг него.

00:01:55.920 --> 00:01:59.040
Модели нужны были не лучшие слова, а лучшая поддержка.

00:01:59.180 --> 00:02:02.920
Так началась эволюция от промп-инженеринга к контекстному инженерингу.

00:02:03.160 --> 00:02:04.740
Три фазы эволюции ИИ.

00:02:05.100 --> 00:02:06.920
Вот как я вижу эволюцию ИИ.

00:02:07.020 --> 00:02:09.940
Три этапа, каждый из которых меняет фокус для инженеров.

00:02:10.120 --> 00:02:11.740
Первым этапом был промп-инженеринг.

00:02:11.920 --> 00:02:14.920
Он длился примерно с 2022 по 2024 год.

00:02:15.080 --> 00:02:16.220
Главный вопрос был прост.

00:02:16.220 --> 00:02:17.420
Что мне сказать модели?

00:02:17.540 --> 00:02:20.600
Вы пишете одну инструкцию, получаете один ответ и все.

00:02:20.780 --> 00:02:22.660
Вся суть была в формулировках и тоне.

00:02:22.860 --> 00:02:24.580
Для простых задач этого было достаточно.

00:02:24.840 --> 00:02:29.320
Затем наступил второй этап – контекстный инженеринг с 2024 по 2025 год.

00:02:29.480 --> 00:02:33.040
Вопрос сменился с «что сказать» на «что должна видеть модель».

00:02:33.040 --> 00:02:36.260
Инженеры поняли, что данные важнее способа запроса.

00:02:36.360 --> 00:02:39.520
Поэтому они создали такие системы, как вызов инструментов,

00:02:39.640 --> 00:02:42.120
RAG и протокол контекста моделей MCP.

00:02:42.260 --> 00:02:45.200
Они позволяют модели получать нужную информацию на лету.

00:02:45.200 --> 00:02:49.840
Вместо того, чтобы втискивать все в один промп, модель сама берет то, что нужно, когда нужно.

00:02:50.020 --> 00:02:52.940
Третий этап, на котором мы сейчас – инженеринг упряжки.

00:02:53.160 --> 00:02:57.860
Начиная с 2026 года, вопрос звучит так, какую систему построить вокруг модели.

00:02:58.060 --> 00:02:59.260
Здесь становится интересно.

00:02:59.580 --> 00:03:03.560
Ведь надежность, память, оркестрация и ограничения приходят не от самой модели,

00:03:03.760 --> 00:03:04.860
а от системы вокруг нее.

00:03:05.080 --> 00:03:06.840
Вот самый простой способ это понять.

00:03:07.040 --> 00:03:08.880
Агент равен модели плюс упряжка.

00:03:09.040 --> 00:03:10.340
Упряжка – это все остальное.

00:03:10.340 --> 00:03:12.540
Модель думает, а упряжка делает все остальное.

00:03:12.680 --> 00:03:15.720
И эта упряжка – тот секретный ингредиент, который заставляет все работать.

00:03:15.880 --> 00:03:19.540
Представьте, модель – это квалифицированный рабочий, талантливый, но ограниченный.

00:03:19.720 --> 00:03:23.760
Упряжка – это мастерская, инструменты, чек-лист, начальник и тормоза.

00:03:23.900 --> 00:03:25.760
Без мастерской рабочему негде работать.

00:03:25.980 --> 00:03:27.820
Без инструментов он ничего не построит.

00:03:28.000 --> 00:03:29.600
Без чек-листа он забудет шаги.

00:03:29.760 --> 00:03:31.380
Без начальника он совершит ошибки.

00:03:31.500 --> 00:03:32.740
А без тормозов он выгорит.

00:03:32.860 --> 00:03:34.560
Упряжка обеспечивает всю эту структуру.

00:03:34.660 --> 00:03:36.240
Так что же именно внутри этой упряжки?

00:03:36.400 --> 00:03:37.480
Давайте заглянем внутрь.

00:03:37.480 --> 00:03:39.180
Что на самом деле содержит упряжка?

00:03:39.340 --> 00:03:41.040
Итак, что входит в состав упряжки?

00:03:41.220 --> 00:03:42.380
Разберем все по порядку.

00:03:42.540 --> 00:03:43.800
Во-первых, цикл агента.

00:03:44.000 --> 00:03:46.000
Это цикл, который поддерживает работу агента.

00:03:46.180 --> 00:03:48.040
Модель думает, а затем решает вызвать инструмент.

00:03:48.280 --> 00:03:50.100
Инструмент запускается и возвращает результат.

00:03:50.340 --> 00:03:53.380
Модель изучает его, снова думает и, возможно, вызывает другой инструмент.

00:03:53.620 --> 00:03:56.440
Цикл продолжается, пока агент не достигнет своей цели.

00:03:56.660 --> 00:03:59.720
Без этого цикла у вас будет только один вопрос и один ответ.

00:03:59.860 --> 00:04:03.280
С ним вы получаете систему, которая решает задачи пошагово.

00:04:03.460 --> 00:04:05.160
Далее – управление контекстом.

00:04:05.160 --> 00:04:08.060
Это критически важно, поскольку у моделей ограниченный объем внимания.

00:04:08.220 --> 00:04:11.120
Их контекстное окно может вместить лишь определенный объем, прежде чем переполнится.

00:04:11.300 --> 00:04:13.100
Здесь в игру вступает управляющая оболочка.

00:04:13.320 --> 00:04:16.840
Она сжимает диалог, суммирует все сообщения и выделяет главное.

00:04:17.100 --> 00:04:19.500
Представьте это как систему архивации для разговора.

00:04:19.620 --> 00:04:22.340
Оболочка организует данные так, чтобы модель видела только актуальное.

00:04:22.540 --> 00:04:25.400
Без этого длинные сессии распадаются, так как модель теряет нить.

00:04:25.600 --> 00:04:27.160
Затем идут инструменты и навыки.

00:04:27.280 --> 00:04:28.440
Это – руки агента.

00:04:28.680 --> 00:04:30.580
Сама по себе модель может только генерировать текст.

00:04:30.580 --> 00:04:33.960
Она не может читать файлы, искать в сети, исполнять код или делать запросы к базе данных.

00:04:34.100 --> 00:04:36.020
Оболочка наделяет ее этими способностями.

00:04:36.200 --> 00:04:41.240
Доступ к файлам, веб-поиск, выполнение кода, запросы к БД – все это инструменты оболочки.

00:04:41.500 --> 00:04:44.640
Модель решает, когда их использовать, а оболочка обеспечивает их работу.

00:04:44.800 --> 00:04:47.340
Память и сохранение сессий – еще один важный элемент.

00:04:47.500 --> 00:04:49.020
Оболочка помнит прошлые сессии.

00:04:49.140 --> 00:04:52.120
Поэтому, когда вы возвращаетесь к агенту завтра, он не начинает с нуля.

00:04:52.280 --> 00:04:55.420
Он помнит ваши предпочтения, контекст проекта и принятые решения.

00:04:55.620 --> 00:04:58.480
Агент учится со временем, потому что оболочка хранит эту историю.

00:04:58.480 --> 00:05:02.040
Защитные механизмы – это уровень безопасности, ограничение поведения агента.

00:05:02.240 --> 00:05:04.020
Рассматривайте их как свод правил агента.

00:05:04.220 --> 00:05:06.720
Максимум шагов до остановки – запрещенные действия,

00:05:06.960 --> 00:05:11.260
подтверждение человеком рискованных операций, вроде записи файлов или отправки писем.

00:05:11.420 --> 00:05:15.120
Без защиты агент мог бы работать вечно или сделать-то, чего вы не планировали.

00:05:15.300 --> 00:05:16.900
Оболочка держит его под контролем.

00:05:17.100 --> 00:05:18.340
Наконец, оркестрация.

00:05:18.540 --> 00:05:21.760
Оболочка может запускать специализированных субагентов для разных задач.

00:05:21.940 --> 00:05:25.740
Один отвечает за поиск, другой – за написание, третий – за проверку.

00:05:25.740 --> 00:05:28.600
Они работают как команда специалистов на стройплощадке.

00:05:28.700 --> 00:05:32.960
Каждый делает свое дело лучше всех, а оболочка следит, чтобы они не мешали друг другу.

00:05:33.060 --> 00:05:35.020
Все эти компоненты – не просто теория.

00:05:35.200 --> 00:05:38.740
Microsoft создала полноценную платформу, воплощающую это на практике.

00:05:38.920 --> 00:05:42.000
Встречайте Microsoft iPhone 3 – корпоративную оболочку.

00:05:42.180 --> 00:05:44.480
Эта платформа и есть Microsoft iPhone 3.

00:05:44.620 --> 00:05:48.720
Это как полноценная мастерская для создания и запуска и агентов в промышленных масштабах.

00:05:48.820 --> 00:05:52.440
И говоря «масштаб», я имею в виду реальные объемы, а не лабораторный эксперимент.

00:05:52.440 --> 00:05:58.700
Foundry сегодня обслуживает более 70 тысяч клиентов, а только за прошлый квартал обработала 100 триллионов токенов.

00:05:58.820 --> 00:06:00.780
Это 100 триллионов – никакой опечатки.

00:06:00.920 --> 00:06:04.220
Каждый день она обрабатывает 2 миллиарда корпоративных поисковых запросов.

00:06:04.300 --> 00:06:07.560
Это производственная платформа для самых крупных рабочих нагрузок в мире.

00:06:07.720 --> 00:06:10.720
Foundry предоставляет вам эту оболочку как управляемый сервис.

00:06:10.900 --> 00:06:14.700
Вам не нужно создавать управление контекстом, память, защиту и координацию с нуля.

00:06:14.880 --> 00:06:15.780
Все это уже встроено.

00:06:15.940 --> 00:06:19.100
Вы предоставляете своего агента, а Foundry обеспечивает рабочую среду для него.

00:06:19.240 --> 00:06:20.720
Теперь поговорим об идентификации.

00:06:20.720 --> 00:06:24.680
Это очень важно. Каждый агент в Foundry получает собственный идентификатор интро.

00:06:24.800 --> 00:06:26.480
По сути, это цифровая личность.

00:06:26.660 --> 00:06:29.720
Представьте это как пропуск сотрудника, выданный на стойке регистрации.

00:06:29.900 --> 00:06:34.820
Агент может входить в службы, получать доступ к данным и действовать от имени организации, как и человек-сотрудник.

00:06:34.940 --> 00:06:38.540
А поскольку каждое действие привязано к этой личности, его можно полностью отследить.

00:06:38.660 --> 00:06:39.460
Почему это важно?

00:06:39.660 --> 00:06:41.580
В компании нужно знать, кто и что сделал.

00:06:41.800 --> 00:06:43.820
Каждое действие регистрируется и отслеживается.

00:06:44.040 --> 00:06:47.060
Foundry подключается к более чем 1400 корпоративным источникам данных,

00:06:47.140 --> 00:06:50.340
от SharePoint и Dynamics 365 до Salisforce и пользовательских баз данных.

00:06:50.340 --> 00:06:53.540
Если ваша компания это использует, у Foundry, вероятно, есть коннектор.

00:06:53.640 --> 00:06:55.420
Так что агент не гадает и не выдумывает.

00:06:55.580 --> 00:06:57.480
Он извлекает реальные данные из реальных систем.

00:06:57.720 --> 00:07:00.240
А значит, ответы основаны на ваших фактических бизнес-данных.

00:07:00.420 --> 00:07:01.300
Затем идет память.

00:07:01.460 --> 00:07:03.320
Foundry включает встроенные типы памяти.

00:07:03.520 --> 00:07:06.060
Процедурная память помогает агенту учиться на прошлых задачах.

00:07:06.180 --> 00:07:08.640
Со временем он становится лучше, как при обучении на рабочем месте.

00:07:08.820 --> 00:07:10.900
Постоянство сеанса означает, что он помнит предыдущие разговоры,

00:07:10.960 --> 00:07:13.140
поэтому ему не нужно начинать с нуля каждый раз, когда вы к нему обращаетесь.

00:07:13.260 --> 00:07:15.620
Это делает взаимодействие последовательным и интеллектуальным.

00:07:15.620 --> 00:07:17.440
Итак, как это работает на самом деле?

00:07:17.580 --> 00:07:21.240
Давайте разберем компоненты, которые Microsoft предоставляет для создания пользовательских связок.

00:07:21.340 --> 00:07:23.920
Фреймворк агентов — создание пользовательских связок.

00:07:24.040 --> 00:07:26.100
Итак, как же на самом деле создать связку?

00:07:26.260 --> 00:07:29.760
Microsoft предоставляет специальный SDK под названием Microsoft Agent Framework,

00:07:29.900 --> 00:07:32.520
который вы можете знать под его прежним названием Semantic Kernel.

00:07:32.660 --> 00:07:34.680
Он был переработан, но идея осталась прежней.

00:07:34.800 --> 00:07:38.280
Он позволяет разработчикам создавать пользовательские связки агентов на Python и C-решетка.

00:07:38.400 --> 00:07:39.940
Фреймворк состоит из трех уровней.

00:07:40.080 --> 00:07:42.380
В основе лежит цикл агента — основной процесс рассуждения,

00:07:42.380 --> 00:07:45.600
где модель думает, вызывает инструменты, получает результаты и снова думает.

00:07:45.680 --> 00:07:48.280
Поверх него располагаются рабочие процессы, шаблоны координации,

00:07:48.400 --> 00:07:49.780
которые управляют несколькими агентами.

00:07:49.880 --> 00:07:53.440
А завершает все уровень связки, оболочка, которая удерживает все вместе.

00:07:53.640 --> 00:07:56.540
Microsoft поставляет пять встроенных шаблонов координации.

00:07:56.860 --> 00:08:00.000
Последовательный запускает агентов одного за другим в заданном порядке.

00:08:00.160 --> 00:08:01.980
Параллельный запускает их все одновременно.

00:08:02.120 --> 00:08:05.640
Передача управления переключает задачу от одного агента к другому по мере необходимости.

00:08:05.800 --> 00:08:08.880
Групповой чат позволяет нескольким агентам общаться в общей беседе.

00:08:08.880 --> 00:08:11.860
И есть еще Magentec — менеджер от Microsoft Research.

00:08:12.120 --> 00:08:14.040
Здесь агент-супервайзер составляет план,

00:08:14.240 --> 00:08:16.880
а затем делегирует работу специализированным субагентам,

00:08:16.900 --> 00:08:19.560
как проектный менеджер распределяет задачи членам команды.

00:08:19.660 --> 00:08:22.060
Каждый шаблон решает свою задачу координации.

00:08:22.260 --> 00:08:23.480
Вот самая лучшая часть.

00:08:23.660 --> 00:08:24.960
Фреймворк можно расширять.

00:08:25.120 --> 00:08:27.880
Вы можете подключить любую нужную вам модель от OpenAI,

00:08:28.060 --> 00:08:31.780
Anthropic и Google Jiminy до Amazon, Bedrock и даже локальных моделей на Allama.

00:08:31.940 --> 00:08:33.560
То же самое касается инструментов.

00:08:33.660 --> 00:08:37.180
Вы подключаетесь через OpenAI, протокол контекста модели или напрямую через код.

00:08:37.180 --> 00:08:41.080
Некоторые опасаются, что использование фреймворка Microsoft привязывает вас к их экосистеме.

00:08:41.200 --> 00:08:41.780
Это не так.

00:08:41.900 --> 00:08:44.620
Фреймворк работает с любым стеком, который вы уже используете.

00:08:44.820 --> 00:08:46.380
Уровень обвязки добавляет такие возможности,

00:08:46.580 --> 00:08:49.780
как доступ к файлам, выполнение кода, промежуточное па для планирования и телеметрия.

00:08:49.920 --> 00:08:53.060
Таким образом, создание агента на этом фреймворке означает построение полноценной системы,

00:08:53.100 --> 00:08:56.360
которая читает файлы, пишет код, планирует многоэтапные задачи и логирует все для отладки.

00:08:56.480 --> 00:08:58.260
Это больше, чем просто чат-интерфейс.

00:08:58.420 --> 00:08:59.260
Вот как это выглядит.

00:08:59.460 --> 00:09:02.120
Представьте себе агента для программирования, построенного на этом фреймворке.

00:09:02.120 --> 00:09:05.820
Вы даете ему задачу, например, добавить новую функцию в существующую кодовую базу.

00:09:05.960 --> 00:09:08.660
Агент начинает с изучения документации, чтобы понять API.

00:09:08.860 --> 00:09:09.800
Затем он пишет код.

00:09:09.920 --> 00:09:12.460
После этого он запускает тесты, чтобы убедиться, что ничего не сломалось.

00:09:12.660 --> 00:09:15.880
Если тест не пройден, он считывает ошибку, исправляет баг и снова запускает тесты.

00:09:15.980 --> 00:09:19.720
Все в рамках той же обвязки, циклично проходя путь мышления и действия проверка до завершения работы.

00:09:19.920 --> 00:09:22.460
Без этой обвязки вам пришлось бы вручную задавать каждый шаг.

00:09:22.580 --> 00:09:25.260
С ней агент самостоятельно справляется со всем рабочим процессом.

00:09:25.420 --> 00:09:28.460
Одним из популярных примеров использования такой обвязки является подтернкло.

00:09:28.460 --> 00:09:33.000
Microsoft сделала его доступным в Foundry, и это отличная демонстрация того, как эти части работают вместе.

00:09:33.140 --> 00:09:34.760
Агенты в стиле Кло и Хермс

00:09:34.760 --> 00:09:36.680
Давайте поговорим об агентах в стиле Кло.

00:09:36.860 --> 00:09:39.860
Название происходит от проектов с открытым исходным кодом, таких как OpenClo.

00:09:40.000 --> 00:09:44.300
Эти агенты живут на вашей машине, ожидают инструкций, а затем самостоятельно выполняют длительные задачи.

00:09:44.380 --> 00:09:46.720
Они всегда готовы подключиться, когда они вам нужны.

00:09:46.860 --> 00:09:49.980
Думайте о них как о личном помощнике, который никогда не уходит на выходной.

00:09:50.140 --> 00:09:52.080
Версия от Microsoft называется Хермс.

00:09:52.200 --> 00:09:56.460
Он работает внутри облачной, песочницы, Foundry и обладает впечатляющими способностями.

00:09:56.460 --> 00:10:00.060
У Хермс есть собственная файловая система, своя память и свой набор инструментов.

00:10:00.140 --> 00:10:04.420
Он может настраивать собственные процедуры обслуживания, очищая старые файлы и организуя свое рабочее пространство.

00:10:04.520 --> 00:10:08.140
А если он понимает, что ему нужен навык, которого у него нет, он может создать его на лету.

00:10:08.220 --> 00:10:09.540
Теперь о главном в агентах Кло.

00:10:09.700 --> 00:10:12.560
Облачные архитекторы называют их «питомцами», а не «скотом».

00:10:12.560 --> 00:10:13.480
Питомцы уникальны.

00:10:13.620 --> 00:10:16.120
Вы даете им имена, заботитесь о них, их нелегко заменить.

00:10:16.260 --> 00:10:17.300
Скот взаимозаменяем.

00:10:17.420 --> 00:10:19.560
Если одна голова выбывает, вы просто берете другую.

00:10:19.680 --> 00:10:21.360
Агенты Кло — это однозначно питомцы.

00:10:21.360 --> 00:10:24.480
У каждого из них свое состояние, своя история и свои выученные модели поведения.

00:10:24.620 --> 00:10:28.400
Эта уникальность делает их мощными, но также затрудняет восстановление и масштабирование.

00:10:28.620 --> 00:10:33.760
Если что-то идет не так, вы не можете просто удалить экземпляр и начать заново, так как потеряете все накопленные знания.

00:10:33.980 --> 00:10:36.200
Решение Microsoft называется «процедуры».

00:10:36.200 --> 00:10:41.100
Это запланированные задачи, которые позволяют агенту проснуться, выполнить обслуживание и снова заснуть.

00:10:41.300 --> 00:10:47.280
Вместо того, чтобы держать песочницу, включенной 24 седьмых, что стоит денег, агент отключается после периода бездействия.

00:10:47.280 --> 00:10:53.800
Система процедур пробуждает его, когда пора что-то сделать, например, очистить старые навыки, выполнить резервное копирование или проверить новые задачи.

00:10:53.920 --> 00:10:55.160
Затем он снова засыпает.

00:10:55.320 --> 00:10:58.640
Это экономит средства, сохраняя доступность агента, когда он вам нужен.

00:10:58.900 --> 00:11:00.820
Песочница изолирует каждый сеанс.

00:11:01.020 --> 00:11:05.360
Файлы, память и конфигурация вашего агента остаются внутри его собственной среды.

00:11:05.460 --> 00:11:11.180
А связующая платформа управляет состоянием между сеансами, поэтому вам не нужно беспокоиться об утечке данных одного агента в другой.

00:11:11.400 --> 00:11:15.060
Создать свою платформу с нуля можно, но большинству компаний это не требуется.

00:11:15.060 --> 00:11:18.940
Фаундри предоставляет готовую платформу со всеми этими встроенными возможностями.

00:11:19.080 --> 00:11:21.720
Главный вопрос, что именно должен делать ваш агент?

00:11:21.900 --> 00:11:24.980
Публикация и совместная работа, где платформы встречаются с людьми.

00:11:25.100 --> 00:11:28.780
Итак, вы создали своего агента, наделили его инструментами, памятью, оркестрацией и песочницей.

00:11:28.860 --> 00:11:30.280
А как люди будут его использовать?

00:11:30.460 --> 00:11:32.260
И вот здесь Фаундри упрощает задачу.

00:11:32.340 --> 00:11:38.160
После того, как агент создан и развернут, вы можете опубликовать его в Microsoft 365 Copilot в Microsoft Teams с одним кликом.

00:11:38.340 --> 00:11:41.400
Не 10 кликов, не 3 дня на внедрение, всего 1 клик.

00:11:41.400 --> 00:11:45.660
И ваш агент появляется там, где люди уже работают, в их почте, чатах и документах.

00:11:45.800 --> 00:11:47.800
Фаундри поддерживает два режима развертывания.

00:11:48.020 --> 00:11:49.540
Во-первых, вспомогательные агенты.

00:11:49.740 --> 00:11:53.500
Они работают от вашего имени, готовят черновики писем, назначают встречи или находят документы.

00:11:53.620 --> 00:11:58.060
Они действуют как ваше продолжение, словно у вас есть очень быстрый ассистент, выполняющий ваши просьбы.

00:11:58.220 --> 00:11:59.760
Во-вторых, агенты автопилота.

00:11:59.900 --> 00:12:01.340
Они более новые и интересные.

00:12:01.500 --> 00:12:04.480
Они действуют от своего имени, имеют собственный адрес электронной почты и свою учетную запись.

00:12:04.640 --> 00:12:06.520
Им не нужно, чтобы вы каждый раз давали им команды.

00:12:06.600 --> 00:12:07.720
Они проявляют инициативу.

00:12:07.720 --> 00:12:10.100
У агентов автопилота есть полноценная учетная запись пользователя.

00:12:10.260 --> 00:12:13.300
Вы можете добавить их в групповой чат-тимс так же, как добавили бы коллегу-человека.

00:12:13.420 --> 00:12:16.080
Они следят за разговором и подключаются, когда могут помочь,

00:12:16.300 --> 00:12:19.180
отчлеживают задачи, отвечают на вопросы о текущей работе команды

00:12:19.180 --> 00:12:21.100
и даже помогают адаптировать новых сотрудников,

00:12:21.260 --> 00:12:23.660
отправляя им нужные документы и знакомя с нужными людьми.

00:12:23.840 --> 00:12:24.800
Вот конкретный пример.

00:12:25.000 --> 00:12:27.440
Допустим, у вас есть агент-менеджер рабочих процессов.

00:12:27.520 --> 00:12:29.120
Вы добавляете его в групповой чат-тимс.

00:12:29.240 --> 00:12:31.800
Кто-то пишет, эй, мне нужен отчет за третий квартал к пятнице.

00:12:31.800 --> 00:12:34.160
Агент понимает, что эта задача, требующая действий.

00:12:34.260 --> 00:12:36.380
Он создает задачу, назначает ее нужному сотруднику

00:12:36.380 --> 00:12:38.500
и ставит напоминание на четверг, чтобы проверить прогресс.

00:12:38.660 --> 00:12:40.120
Никто не давал ему таких указаний.

00:12:40.260 --> 00:12:42.440
Он просто увидел, что нужно сделать, и сделал это.

00:12:42.600 --> 00:12:45.180
Харнеса сберет на себя управление всеми разрешениями в фоновом режиме.

00:12:45.280 --> 00:12:47.920
Только авторизованные пользователи могут взаимодействовать с агентом в групповом чате.

00:12:48.100 --> 00:12:50.840
Агент видит только те сообщения, которым у него есть доступ, и игнорирует остальные.

00:12:51.000 --> 00:12:53.520
Он соблюдает те же правила контроля доступа, что и ваши сотрудники.

00:12:53.700 --> 00:12:55.880
Вот почему разработка Харнеса действительно окупается.

00:12:55.880 --> 00:12:58.560
Агент перестает быть просто чат-ботом во вкладке браузера.

00:12:58.680 --> 00:13:00.660
Он становится полноценным членом команды.

00:13:00.740 --> 00:13:03.740
Он работает там же, где и вы, по тем же принципам, что и ваша команда,

00:13:03.860 --> 00:13:05.940
а все благодаря Харнеса с системе вокруг модели,

00:13:06.080 --> 00:13:09.120
отвечающей за идентификацию, права, развертывание и интеграцию.

00:13:09.320 --> 00:13:11.800
Без Харнеса с вам пришлось бы проверять еще одно окно чата.

00:13:11.940 --> 00:13:14.100
Но любому мощному инструменту нужны средства защиты.

00:13:14.260 --> 00:13:16.780
Давайте поговорим об ограничениях, которые делают все это безопасным.

00:13:17.020 --> 00:13:19.060
Ответственный ИИ и управление в среде Харнеса с.

00:13:19.180 --> 00:13:19.960
В этом-то и суть.

00:13:20.160 --> 00:13:22.940
Разработка Харнеса с – это не только расширение возможностей агентов.

00:13:22.940 --> 00:13:25.200
Это обеспечение их безопасности и надежности.

00:13:25.400 --> 00:13:28.380
Агент, который может отправлять письма, изменять файлы и общаться в чатах,

00:13:28.520 --> 00:13:30.420
обладает большой мощью, но она требует контроля.

00:13:30.540 --> 00:13:32.900
Представьте, что вы даете сотруднику ключи от здания.

00:13:33.080 --> 00:13:34.820
Вы хотите, чтобы он выполнял свою работу,

00:13:35.020 --> 00:13:37.580
но устанавливаете правила, к чему и когда он может получить доступ.

00:13:37.700 --> 00:13:40.960
Подход Microsoft основан на стандарте ответственного ИИ.

00:13:41.140 --> 00:13:45.660
Все действия определяют шесть принципов – справедливость, надежность и безопасность,

00:13:45.860 --> 00:13:49.280
конфиденциальность, инклюзивность, прозрачность и подотчетность.

00:13:49.440 --> 00:13:51.520
Это не просто красивые слова на плакате.

00:13:51.520 --> 00:13:55.440
Это реальный фундамент, на котором с самого начала строится вся платформа.

00:13:55.560 --> 00:13:58.500
Именно в Харнеса с эти принципы превращаются в работающий код.

00:13:58.680 --> 00:14:00.480
Ограничения лимитируют действия агента.

00:14:00.660 --> 00:14:04.500
Хуки жизненного цикла позволяют применять правила на каждом этапе выполнения работы агента.

00:14:04.700 --> 00:14:08.400
До запуска, после запуска, перед вызовом инструмента, после получения результата,

00:14:08.580 --> 00:14:10.640
вы можете встроить собственные проверки в любой момент.

00:14:10.880 --> 00:14:13.420
Хотите запретить агенту доступ к определенным базам данных?

00:14:13.540 --> 00:14:14.340
Это можно сделать.

00:14:14.540 --> 00:14:17.240
Хотите требовать одобрения человека перед отправкой агентом электронного письма?

00:14:17.360 --> 00:14:18.360
Это тоже можно сделать.

00:14:18.360 --> 00:14:20.140
Обе эти задачи легко настраиваются.

00:14:20.360 --> 00:14:23.820
Azure Well-Earchitected Framework содержит специальные рекомендации для рабочих нагрузок с E.

00:14:23.940 --> 00:14:26.940
Они охватывают все, от шифрования данных до реагирования на инциденты.

00:14:27.140 --> 00:14:31.580
Идея в том, что создание E-системы принципиально не отличается от создания любой другой корпоративной системы.

00:14:31.700 --> 00:14:34.840
Вам по-прежнему необходима безопасность, надежность и операционное совершенство.

00:14:35.000 --> 00:14:38.900
Well-Earchitected Framework дает структурированный подход ко всему этому, чтобы вы не запутались.

00:14:39.060 --> 00:14:41.240
Кроме того, существует Cloud Adoption Framework.

00:14:41.240 --> 00:14:55.800
Он предлагает четырехэтапный процесс управления и, во-первых, выявление рисков, что может пойти не так, во-вторых, оценка воздействия, насколько серьезными будут последствия, в-третьих, смягчение с помощью контроля, что можно предпринять для предотвращения, в-четвертых, эксплуатация с мониторингом, как обнаруживать проблемы по мере их появления.

00:14:55.800 --> 00:15:00.040
Это практический пошаговый подход, превращающий абстрактные опасения в конкретные действия.

00:15:00.180 --> 00:15:03.120
Для каркасов агентов это означает несколько ключевых моментов.

00:15:03.180 --> 00:15:06.200
Ограничение максимального количества шагов, чтобы агент не работал вечно.

00:15:06.380 --> 00:15:08.980
Ограничение инструментов, чтобы он имел доступ только к разрешанному.

00:15:09.160 --> 00:15:11.300
Етапы подтверждения человеком для действий с высоким риском.

00:15:11.480 --> 00:15:14.120
Журналы аудита, чтобы каждое решение фиксировалось и проверялось.

00:15:14.280 --> 00:15:17.480
Фильтры безопасности контента, оцеивающие проблемные ответы до их появления.

00:15:17.660 --> 00:15:20.600
Все эти элементы работают вместе, чтобы держать вашего агента под контролем.

00:15:20.740 --> 00:15:24.080
Microsoft предоставляет встроенные средства безопасности контента и оценки Foundry.

00:15:24.080 --> 00:15:26.900
Вы можете протестировать агента по ряду критериев перед развертыванием.

00:15:27.080 --> 00:15:28.440
Соблюдает ли он тему разговора?

00:15:28.500 --> 00:15:30.440
Правильно ли он обрабатывает конфиденциальные данные?

00:15:30.600 --> 00:15:32.940
Отказывается ли он от выполнения нежелательных запросов?

00:15:33.060 --> 00:15:37.380
Вы можете запускать эти оценки автоматически и получать баллы до публикации агента.

00:15:37.520 --> 00:15:40.640
Так вы обнаружите проблемы на ранней стадии, а не после сбоев.

00:15:40.760 --> 00:15:41.760
Это полная картина.

00:15:41.980 --> 00:15:45.340
От простого промпта до безопасного автономного агента промышленного уровня.

00:15:45.520 --> 00:15:51.460
Модель мыслит, а каркас делает все остальное – координацию, защиту и управление, обеспечивая доверие.

00:15:51.460 --> 00:15:53.500
Итак, подведем итоги трансформации.

00:15:53.500 --> 00:15:55.760
Мы начали с промптов, с одним примером – ваншот.

00:15:55.900 --> 00:15:57.380
Написал промпт, получил ответ.

00:15:57.540 --> 00:15:58.840
Это работало для простых задач.

00:15:59.060 --> 00:16:00.880
Затем мы перешли к проектированию контекста.

00:16:01.020 --> 00:16:04.000
Управляйте тем, что видит модель, загружая нужную информацию вовремя.

00:16:04.120 --> 00:16:05.740
Это работало для более сложных задач.

00:16:05.940 --> 00:16:08.360
А теперь мы пришли к полноценному проектированию каркасов.

00:16:08.500 --> 00:16:12.620
Создайте полную систему вокруг модели с памятью, инструментами, координацией и защитой.

00:16:12.780 --> 00:16:13.620
Вот главный вывод.

00:16:13.800 --> 00:16:16.680
Агент надежен лишь настолько, насколько надежна система вокруг него.

00:16:16.900 --> 00:16:20.380
Модель важна, безусловно, но именно каркас определяет успех в продакшене.

00:16:20.380 --> 00:16:25.240
Можно иметь лучшую модель в мире, но без хорошего каркаса она провалится в реальных задачах.

00:16:25.320 --> 00:16:29.800
А с достойной моделью и отличным каркасом она всегда будет превосходить ожидания.

00:16:30.040 --> 00:16:31.000
Вот ваша задача.

00:16:31.100 --> 00:16:34.300
В своем следующем и проекте думайте шире, чем просто о промпте.

00:16:34.460 --> 00:16:38.580
Не спрашивайте, что сказать модели, спрашивайте, какую систему нужно построить вокруг нее.

00:16:38.740 --> 00:16:41.680
Именно этот сдвиг в мышлении отделяет демоверсии от рабочих систем.

00:16:41.860 --> 00:16:45.500
В следующем эпизоде мы подробнее разберем один компонент такой системы – память.

00:16:45.500 --> 00:16:50.240
Как агенты учатся со временем, как они помнят сделанное и как это меняет их возможности.

00:16:50.500 --> 00:16:52.060
Подпишитесь, чтобы не пропустить.
