LLamjinLab
ИИ-агентЗнаков 11943Время чтения≈ 30 мин

На каком языке писать AI-агент: Python, TypeScript и инженерия продуктов следующего поколения

Нужен ли для AI-агента Python или TypeScript? Эта статья, опираясь на историю deep learning, продуктизацию агентных решений, типовые системы, асинхронные event-стримы и разделение инженерных ролей, рассматривает выбор языка для следующих поколений AI-приложений.

AIАгентИспользование инструментовРабочие процессыПрограммирование

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

С одной стороны, утверждалось, что Python массово применяется на ранних этапах AI-агентов потому, что deep learning, научные вычисления, обучение моделей, эксперименты в ноутбуках и экосистема PyTorch/TensorFlow исторически строились вокруг Python. В самом начале AI основной субъект был именно «моделью», поэтому исследователи по умолчанию брали наиболее удобный Python для склейки LLM, вызовов инструментов, парсеров вывода, векторных БД и разных экспериментальных скриптов.

С другой стороны, есть мнение, что сегодня более подходящим для продуктных AI-агентов становится TypeScript. Потому что зрелый Agent всё чаще уже не остаётся в прототипах и научных статьях, а живёт в вебе, плагинах, панелях рабочих процессов, расширениях IDE, корпоративных бекендах, SaaS-сервисах и разных пользовательских интерфейсах. На этом этапе всё важнее становятся типовая система, event-стримы, разделение схем между фронтендом и бэкендом, структура tool calling, объекты прав доступа и синхронизация UI-состояния.

Мне кажется, это не спор «Python умер» или «TypeScript победит». Более точный вывод такой: эпоха AI-агентов смещается от инженерии моделей к инженерии продукта; Python остаётся важным, но TypeScript становится ключевым языком продуктового и runtime-уровней Agent.

1. Почему ранняя экосистема AI и AI-агентов была естественно ориентирована на Python

1. AI изначально фокусировался на модели, а не на продукте

Ключевая задача ранней инженерии deep learning была в том, как обучить модель, настроить гиперпараметры, обработать тензоры, построить вычислительный граф, запустить эксперименты на GPU. На этом этапе особенно важны не веб-интерфейсы, не права пользователя, не биллинг и не многоплатформенные UI, а быстрое подтверждение гипотез о модели.

Python как раз очень хорошо подходит для такой работы: синтаксис простой, удобна интерактивная среда, экосистема зрелая, а производительность берётся через бэкэнды на C/C++/CUDA. Исследователь может писать мало кода на Python, отдавая тяжёлые вычисления на низкоуровневые библиотеки.

NumPy, SciPy, Jupyter, PyTorch, TensorFlow, scikit-learn длительное время были базовой рабочей станцией AI и научных вычислений. Поэтому многие ранние прототипы AI-агентов фактически были «LLM + Python-склеивающий код»: связка prompt, API модели, функций-инструментов, парсера вывода, векторного поиска и цикла выполнения задачи.

2. Преимущество Python рождалось из экосистемы научных вычислений

Преимущество Python в AI — не только в том, что он «простой». Главное — он очень рано сформировал полноценную экосистему научных вычислений.

NumPy дал многомерные массивы, линейную алгебру, генерацию случайных чисел, преобразование Фурье и базовые примитивы. SciPy, pandas, scikit-learn затем развили это в статистику, машинное обучение и анализ данных. Jupyter Notebook дал исследователю возможность писать код, сразу видеть результаты и быстро отлаживать эксперименты.

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

Поэтому Python не победил «на пустом месте». Он победил, потому что:

  • низкий порог вхождения;
  • раннее, мощное научное сообщество и экосистема;
  • зрелая интеграция с C/C++/CUDA;
  • Notebook отлично подходит для экспериментов;
  • учебные материалы, статьи и репозитории open source в AI преимущественно на Python.

3. Динамические графы PyTorch ещё больше укрепили позицию Python

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

TensorFlow в начале сильнее делал ставку на статические графы, но затем ввёл eager execution, позволив выполнять операции «как обычный Python-код» сразу. Уже этот сдвиг показывает: на этапах исследования и экспериментов разработчики очень ценят интерактивность, интуитивность и скорость отладки.

Именно поэтому ранние AI-агенты почти естественно выбирали Python. Исследователю не нужно сразу строить полноценный продукт, достаточно связать модель, инструменты, окружение и парсинг вывода. Python как раз оказался удобным «склеивающим» языком.

2. Почему сегодня TypeScript всё больше подходит для Agent

1. Агент уже не «скрипт модели», а целая продуктовая система

Современный AI-агент уже не просто «пользователь задал вопрос — модель ответила». По-настоящему рабочий Agent обычно включает:

  • вызовы LLM API;
  • tool calling / function calling;
  • многопереходное состояние задачи;
  • подтверждение пользователем и участие человека;
  • RAG и векторные базы данных;
  • узлы рабочего процесса;
  • браузерная автоматизация;
  • чтение/запись файлов;
  • система разрешений;
  • биллинг;
  • логи, трассировка, оценка и мониторинг;
  • realtime-обновление UI.

Это уже не просто инженерия модели, а полноценная инженерия продукта.

Когда Agent переходит на продуктовый уровень, преимущества TypeScript становятся заметнее. Причина в том, что большинство пользовательских сценариев Agent изначально лежат в web-экосистеме: чат-интерфейс, панель рабочего процесса, браузерное расширение, веб-приложение, desktop-приложение на Electron, плагин VS Code, Slack/Discord-бот, API Route, Serverless, Edge Runtime и т.д.

Эти среда долгие годы исторически живут в JavaScript/TypeScript.

2. TypeScript ближе к UI и потокам событий

Agent сильно завязан на события.

Реальный запуск Agent — это обычно не «один запрос — один ответ», а последовательность:

  • думаем и одновременно выдаём промежуточный вывод;
  • выдаём и при этом вызываем инструменты;
  • ждём подтверждения пользователя;
  • отменяем или повторяем на середине выполнения;
  • после ответа инструмента возвращаем состояние;
  • во frontend в реальном времени показываем промежуточные шаги;
  • после ошибки восстанавливаем контекст;
  • между несколькими Agent или несколькими узлами workflow пересылаем результаты.

Это прямо созвучно веб-модели событий, stream, WebSocket, Server-Sent Events и менеджменту состояния UI.

Python, конечно, умеет async, может писать FastAPI, WebSocket, фоновые задачи и потоковый вывод. Но если сам Agent-продукт — веб-приложение, TypeScript позволяет легче держать единым фронт, бэкенд, схемы инструментов, UI-состояние и типы API.

3. Агент чаще ломается на структуре, а не на «глупом» моделировании

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

Agent очень часто падает на инженерии структуры:

  • неправильно заданы поля входных параметров инструмента;
  • несоответствие JSON-схем;
  • изменение структуры ответа API;
  • разнобой форматов message;
  • повреждение workflow state на каком-то этапе;
  • рассинхронизация UI-событий и серверного состояния;
  • неполный объект разрешений;
  • искажение контекста при восстановлении многопереходного диалога.

В Agent-системах много структурированных объектов постоянно перемещается. Здесь типовая система — не «идеологическая чистота», а базовая инфраструктура, снижающая вероятность краха.

Здесь и проявляется ценность TypeScript. Он позволяет заранее чётко описывать tool input/output, agent state, message format, workflow node, permission object, external API response. Многие ошибки больше не доходят до продакшн-рантайма, потому что их отлавливает типизация на этапе разработки.

4. TypeScript лучше подходит для product-level Agent Runtime

Если вы строите framework для агентов, SDK, систему плагинов, движок workflow или frontend-видимый runtime, преимущества TypeScript расширяются.

Причина проста: ваше решение скорее всего будут интегрировать в веб, в сервисы, в браузерные расширения, desktop-приложения, плагин VS Code, Serverless-функции или корпоративные системы. В этих сценариях экосистема TypeScript более цельная.

Поэтому в экосистеме Agent последних лет заметно растёт число TypeScript-проектов. Vercel AI SDK делает акцент на единый API для генерации текста, структурированных объектов, вызовов инструментов и Agent; Mastra позиционирует себя как TypeScript-фреймворк для AI-агентов; OpenAI Agents SDK поставляется и как Python-версия, и как JavaScript/TypeScript.

Это отражает тенденцию: Agent перестаёт служить только исследователю и начинает служить продуктовым командам и full-stack разработчикам.

3. Python и TypeScript — не замена, а разделение ролей

1. Python по-прежнему лучше для уровня модели, данных и эксперимента

То, что TypeScript хорошо подходит продуктовой части Agent, не означает, что Python теряет значимость.

Напротив, Python остаётся ядром для многих AI-систем, особенно для:

  • обучения моделей;
  • очистки данных;
  • embedding pipeline;
  • оффлайн батч-процессов;
  • систем оценки;
  • экспериментов с поиском;
  • feature engineering в машинном обучении;
  • научных вычислений;
  • быстрого прототипирования в ноутбуках;
  • интеграции с PyTorch/TensorFlow/scikit-learn.

Если вашему Agent нужны сложная текстовая обработка, оценка качества модели, анализ данных, построение векторов и оффлайн задачи, Python по-прежнему естественный выбор.

2. TypeScript лучше подходит для уровня продукта, интеракции и оркестрации

TypeScript удобнее покрывает другую часть:

  • фронтенд чат-интерфейса;
  • оркестрацию workflow;
  • описание tool schema;
  • API Route;
  • управление правами пользователя;
  • биллинг и учёт аккаунтов;
  • системы плагинов;
  • браузерные и IDE-расширения;
  • Serverless / Edge деплой;
  • стриминг-вывод и синхронизацию UI-состояний.

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

3. Более реалистичная архитектура: Python как источник возможностей, TypeScript как продуктовая оболочка

Наиболее рабочий вариант, который я разделяю, такой:

  • Python для уровня модели, данных, оценки, оффлайн задач и экспериментов;
  • TypeScript для product-слоя, оркестрации Agent, front-end интеракций, плагин-слоя и пользовательского runtime.

Это не победа одного языка над другим, а естественная инженерная стратификация по мере созревания AI-приложений.

Раньше AI = модель, поэтому Python был главным.

Сейчас Agent = модель + инструменты + состояние + workflow + UI + права + деплой + мониторинг, поэтому роль TypeScript будет расти.

4. От «писать Agent» к «делать продукт на Agent»

1. Ранний Agent — это исследовательский прототип

Типичный ранний Agent выглядел как Python-скрипт:

  • вызов LLM;
  • разбор вывода модели;
  • решение о вызове инструмента;
  • возврат результата инструмента в контекст;
  • повторный запуск вывода модели;
  • финальный ответ.

Такая система ближе к исследовательскому прототипу. Её цель — «запустить ли вообще», а не «обеспечивать стабильную работу для пользователей».

2. Новое поколение Agent — это долгоработающее приложениe

Новый Agent — не просто скрипт, а приложение со сроком жизни.

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

Значит, выбирать язык уже нельзя только по вопросу «кто лучше пишет работу с моделью». Нужно смотреть, что лучше:

  • для продуктового взаимодействия;
  • для сложного состояния;
  • для совместного использования типов с фронтендом;
  • для командной разработки;
  • для деплоя в реальную бизнес-среду;
  • для долгосрочной поддержки.

Это и есть корневая причина роста важности TypeScript.

5. Что советовать отдельным разработчикам

1. Если вы только начинаете с AI, сначала изучайте Python

Если вы только входите в AI, Python по-прежнему наиболее рациональный первый язык.

Потому что подавляющее большинство туториалов по машинному обучению, анализу данных, обучению моделей, примеров в ноутбуках и open-source проектов с моделями по-прежнему на Python. Вам нужно понять данные, модель, embedding, RAG, оценку и базовые вызовы LLM API — Python здесь самый понятный вход. Для систематического входа в основы интеллектуальных агентов, от ReAct до памяти, RAG и контекстной инженерии можно использовать «Hello-Agents: Open Source Tutorial for Building AI Agents from Scratch».

2. Если хотите делать продукт на Agent, TypeScript всё равно придётся подтянуть

Если ваша цель — не просто демо, а публичный сайт, SaaS, плагин, инструмент workflow или онлайн-агент, TypeScript почти неизбежен.

Вам не обязательно становиться frontend-экспертом, но полезно понимать:

  • типовую систему TypeScript;
  • API schema;
  • базовую архитектуру React/Next.js;
  • streaming response;
  • типизацию для tool calling;
  • синхронизацию состояния фронтенда и бэкенда;
  • деплой Serverless / Edge;
  • базовую продуктовую инженерную культуру web.

Это напрямую влияет на то, станет ли ваш Agent полноценным продуктом, а не скриптом.

3. Если хотите строить Agent Infra, TypeScript стоит ценить ещё больше

Если вы делаете Agent framework, workflow-систему, протокол плагинов, marketplace инструментов, платформу для browser automation, IDE-агент или enterprise Agent Runtime, ценность TypeScript выше.

Потому что всё это в итоге внедряют продуктовые команды, full-stack инженеры и web-разработчики. Типизация, пакетная экосистема и единый фронт-энд/бэк-энд опыт делают TypeScript особенно заметным в Agent-Infra.

6. Мой вывод: эпоха — «двойной стек», но главный акцент уходит в product engineering

На каком языке писать AI-агента? Мой ответ:

На этапе обучения и экспериментов — Python; на этапе продукте и runtime — приоритет TypeScript; зрелые AI-агентные системы, скорее всего, будут устроены как двойной стек.

Python не исчезнет, потому что модельный, датасетный и экспериментальный уровни AI по-прежнему сильно завязаны на него.

TypeScript будет становиться важнее, потому что Agent переходит от «экспериментов с моделью» к «инженерии продукта». Пока Agent должен жить в вебе, плагинах, workflow-системах, IDE и UI, позиция TypeScript будет только усиливаться.

Поэтому кажется, что спор формально ведётся о Python и TypeScript, а фактически — о более широком вопросе:

Где сейчас основной фронт AI: всё ещё в лаборатории моделей или уже на полигоне продуктовой инженерии?

Моё мнение: модель по-прежнему важна, но просто «запросить модель» уже не дефицитная способность. Дефицит в будущем — умение связать модель, инструменты, данные, права, UI, workflow и реальный бизнес-процесс в стабильную и полезную систему.

Вот в этом и есть направление эпохи AI-агентов.

Частые вопросы

AI-агент должен быть на Python или TypeScript?

Единственного ответа нет; ближе к модели разделения труда: на этапе обучения и экспериментов используется Python, на этапе продукта и runtime приоритет отдают TypeScript, а зрелые системы обычно строятся как двойной стек — Python для модели/данных/оценки, TypeScript для продукта/оркестрации/frontend-интеракции.

Почему ранние AI-агенты чаще писались на Python?

Потому что экосистемы deep learning, научных вычислений, обучения моделей и ноутбуков долгое время строились вокруг Python (NumPy, PyTorch, TensorFlow, scikit-learn). Большинство ранних Agent были «LLM + Python-склейка», где связывали prompt, API модели, функции-инструменты, парсер вывода и цикл задач.

Почему продуктовую часть Agent всё больше тянет на TypeScript?

Потому что реальные пользовательские Agent в основном живут в web-экосистеме: чат-интерфейсы, браузерные расширения, панели workflow, расширения IDE, корпоративные панели. Там нужны типовые системы, event-стримы, единые schema между фронтендом и бэкендом и синхронизация UI-состояний. TypeScript помогает согласовать фронтенд, бэкенд, tool schema и типы API, а также раньше ловить структурные ошибки на этапе компиляции.

С чего начать новичку?

Сначала учите Python для входа в AI: понимание данных, модели, embedding, RAG, оценки и базовых вызовов LLM API; когда захотите превратить demo в публикуемый сайт, SaaS, плагин или онлайн-агент, тогда добавляйте TypeScript.

Источники

Share

Поделиться статьёй