OpenHands: открытый ИИ‑агент для программирования — разбор

OpenHands — это открытая платформа для разработки ПО с ИИ, построенная вокруг агента, который может инспектировать ваш репозиторий, редактировать файлы, выполнять команды и запускать тесты. Это часть перехода к агентной разработке ПО: вы даёте агенту полноценную задачу, а он последовательно проходит шаг за шагом, пока не выполнит её или не запросит вашей помощи.

В этой статье мы разберём архитектуру OpenHands и его ключевые возможности, настроим запуск с локальной моделью и сравним его с Claude Code, Cursor и GitHub Copilot.

Что такое ИИ‑агенты? Запишитесь на наш трек «Основы ИИ‑агентов», чтобы узнать, как ИИ‑агенты могут изменить вашу работу.

Что такое OpenHands?

OpenHands — это открытая платформа для создания и запуска ИИ‑агентов, работающих с кодом.

Название охватывает две вещи. Во‑первых, это проект — набор репозиториев с SDK, сервером, браузерным интерфейсом и хостинговым сервисом. Во‑вторых, это сам кодирующий агент, который работает поверх всего этого.

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

• SDK программного агента: набор Python‑ и REST‑API для создания агентов, работающих с кодом, и движок для OpenHands CLI и OpenHands Cloud
• Agent Server: предоставляет выполнение агентов, диалоги, инструменты и рабочие пространства через REST‑ и WebSocket‑API
• Agent Canvas: единый браузерный интерфейс для диалогов, файлов, вывода терминала, конфигурации моделей, бэкендов и автоматизаций
• OpenHands Cloud: управляемый коммерческий сервис для команд, которые не хотят поддерживать собственный бэкенд и инфраструктуру песочниц

Когда говорят «OpenHands», чаще всего имеют в виду именно агента. С ним мы и будем работать в этой статье.

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

Рабочее пространство необязательно должно быть вашим ноутбуком. Агенты могут использовать локальную машину как рабочее место или запускаться во временных пространствах, например в Docker или Kubernetes.

OpenHands также не привязывает вас к одному провайдеру моделей. Можно использовать Claude, GPT или любой другой LLM, включая локальные модели. Agent Canvas даже запускает сторонних агентов, таких как Claude Code и Codex, вместо агента OpenHands по умолчанию.

Вкратце: OpenHands — это открытая агентная платформа, которую вы можете запускать на своих условиях.

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

OpenHands работает в цикле.

Чат‑ассистент получает ваш промпт и возвращает текст. Агент OpenHands получает задачу, выполняет действие, смотрит на результат и решает, что делать дальше.

Цикл агента OpenHands

Общая схема такая:

• Получить задачу: вы описываете цель простыми словами, например: «Исправить месячный отчёт, чтобы данные за месяцы разных лет не сливались»
• Изучить репозиторий: агент перечисляет директории, открывает файлы и ищет код, связанный с задачей
• Сформировать план: дробит задачу на шаги и записывает их в трекер задач
• Редактировать или создавать файлы: меняет код с помощью редактора файлов
• Запускать команды и тесты: запускает тестовый набор или приложение в терминале
• Проверять результаты: читает вывод, включая ошибки и проваленные утверждения
• Итерировать: если что‑то всё ещё не работает, возвращается, корректирует план и пробует ещё раз

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

Шаг 6 отличает OpenHands от конкурентов. Инструмент автодополнения кода не видит, что происходит при запуске сгенерированного им кода. OpenHands видит и может отреагировать на проваленный тест и исправить причину.

Ключевые возможности OpenHands

Автодополнение подсказывает текст, а OpenHands действует в вашем проекте. Вот как.

Редактирование кода

OpenHands правит файлы напрямую и не ограничивается одним файлом за раз.

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

Терминал и использование инструментов

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

Вы также можете подключать серверы MCP (Model Context Protocol), чтобы дать агенту инструменты, под которые он изначально не заточен, например трекер задач или клиент базы данных.

Понимание репозитория

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

OpenHands открывает репозиторий и исследует его. Он может прочитать README, пройти по импортам и посмотреть существующие тесты, чтобы понять структуру проекта. Поэтому его изменения чаще лучше вписываются в уже имеющийся код.

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

Выбор модели

Вызовы модели идут через LiteLLM, поэтому можно использовать любого провайдера и модель, которую он поддерживает. В документации OpenHands рекомендуются модели семейств Claude, GPT и Gemini, а также открытые модели, хорошо показывающие себя в OpenHands Index.

Если ваш код не может покидать вашу машину, можно запустить локальную модель. OpenHands подключается к локальным серверам, таким как LM Studio, Ollama, vLLM и SGLang.

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

Автономное выполнение задач

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

Agent Canvas идёт дальше за счёт автоматизаций. Они интегрируются со Slack, GitHub, Linear и другими инструментами и запускаются по расписанию или по событиям вебхуков.

Но автономность не гарантирует корректность. Перед слиянием всё равно нужно просмотреть diff и результаты тестов.

Как пользоваться OpenHands

Лучший способ понять OpenHands — дать ему баг и посмотреть, что он сделает.

В этом разделе мы запустим OpenHands локально в Docker, подключим его к локальной модели через Ollama и попросим исправить баг в небольшом проекте на Python.

Установка OpenHands

Запустить OpenHands можно несколькими способами:

• Запуск через CLI: установите командой uv tool install openhands --python 3.14, затем запустите графический интерфейс командой openhands serve

• Docker: запустите контейнер приложения напрямую одной командой docker run

• Agent Canvas: новый браузерный клиент, который подключается к локальным, само‑хостинговым, Cloud‑ или Enterprise‑бэкендам

• OpenHands Cloud: хостинговая версия, если вы не хотите ничего запускать у себя

Мы используем вариант с Docker и локальным GUI. В документации OpenHands он отмечен как устаревшее браузерное приложение на базе Docker и вместо него рекомендуется Agent Canvas, но этот способ всё ещё описан и остаётся самым быстрым для запуска GUI.

Понадобится Docker Desktop на macOS, Linux или Windows с WSL. На macOS откройте Docker Desktop, перейдите в Settings > Advanced и включите Docker socket по умолчанию.

Затем запустите приложение:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8

OpenHands использует монтирование Docker‑сокета, чтобы запускать отдельный контейнер‑песочницу, и агент выполняет команды внутри этой песочницы, а не на вашей машине.

Когда в логах появится, что сервер запущен, откройте в браузере http://localhost:3000.

Приветственная страница OpenHands

Подключите модель

OpenHands ничего не сделает, пока вы не укажете модель.

Мы используем Devstral Small 2 — 24‑миллиардную модель Mistral, ориентированную на агентное программирование. Её достаточно для одного RTX 4090 или Mac с 32 ГБ ОЗУ. Требуется Ollama версии 0.13.3 или новее.

Запустите Ollama с увеличенным окном контекста и загрузите модель:

OLLAMA_CONTEXT_LENGTH=32768 OLLAMA_HOST=0.0.0.0:11434 ollama serve &
ollama pull devstral-small-2:24b

Не игнорируйте длину контекста. Значение по умолчанию в Ollama — 4096 токенов, чего недостаточно даже для системного промпта OpenHands. В документации просят как минимум 22000.

В OpenHands откройте Settings, перейдите на вкладку LLM и включите Advanced. Затем укажите:

1. Custom Model: openai/devstral-small-2:latest

2. Base URL: http://host.docker.internal:11434/v1

3. API Key: любое заполнительное значение, например local-llm

Настройки LLM для локальной модели Ollama

Префикс openai/ говорит OpenHands обращаться к Ollama через её OpenAI‑совместимый API. Ключ API не используется, но поле не может быть пустым.

Откройте репозиторий

По умолчанию OpenHands не видит ваши файлы. Нужно примонтировать проект в песочницу.

Для примера потребуется папка budget-tracker/project с двумя файлами. Первый суммирует расходы по месяцам:

# budget.py
def monthly_totals(transactions):
    """Sum spending per month, keyed as 'YYYY-MM'.

    Each transaction is a (date, amount) tuple, for example ("2025-01-15", 42.0).
    """
    totals = {}
    for date, amount in transactions:
        month = date[5:7]
        totals[month] = totals.get(month, 0) + amount
    return totals

В докстроке обещаются ключи формата YYYY-MM, но date[5:7] берёт только месяц. Январь 2025 и январь 2026 попадут в одну корзину.

Второй файл содержит два теста, которые ловят баг:

# test_budget.py
from budget import monthly_totals


def test_same_month_in_different_years():
    transactions = [
        ("2025-01-10", 50.0),
        ("2025-01-20", 100.0),
        ("2026-01-12", 60.0),
    ]
    assert monthly_totals(transactions) == {"2025-01": 150.0, "2026-01": 60.0}


def test_single_month():
    transactions = [("2026-03-01", 20.0), ("2026-03-15", 5.5)]
    assert monthly_totals(transactions) == {"2026-03": 25.5}

Превратите папку в Git‑репозиторий, чтобы потом увидеть, что изменил агент:

cd budget-tracker
git init
git add .
git commit -m "Initial commit"

Если сейчас запустить python -m pytest, оба теста упадут:

Проваленные тесты

Чтобы дать OpenHands доступ, остановите контейнер и добавьте одну строку к команде docker run:

-e SANDBOX_VOLUMES=$HOME/budget-tracker:/workspace:rw \

Полная команда теперь такая:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -e SANDBOX_VOLUMES=$HOME/Desktop/budget-tracker:/workspace:rw \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8

Формат — host_path:container_path:mode. Ваш проект появится в песочнице по пути /workspace, а rw разрешает агенту его редактировать.

Монтируйте только тот проект, который агент должен менять. Всё, что примонтировано с правами записи в /workspace, может быть изменено агентом.

Поставьте агенту задачу

Начните новый диалог и опишите проблему так, как вы бы написали отчёт о баге:

Итоги по месяцам объединяют расходы за один и тот же месяц в разные годы.

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

На этом всё. Не нужно указывать агенту budget.py или строку с ошибкой.

Вывод диалога

Дальше включается описанный ранее цикл агента. Агент просматривает /workspace, читает оба файла и запускает тесты, чтобы увидеть, что падает. Затем правит код и снова запускает тесты.

Агент запускает pytest в терминале песочницы

Проверьте изменения

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

Правильное исправление — одна строка в budget.py:

month = date[:7]

Исправленный budget.py

Также можно выполнить git diff, чтобы увидеть различия.

На что обратить внимание:

• Исходный код: исправление должно быть в budget.py

• Тесты: убедитесь, что агент не правил test_budget.py, чтобы «заставить» утверждения пройти

• Запуск тестов: запустите python -m pytest сами — не полагайтесь на сводку агента

Архитектура OpenHands

У OpenHands шесть основных частей, и у каждой — своя задача.

Как компоненты OpenHands соединяются между собой

ИИ‑модель

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

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

Логика агента

Агент — связующее звено между моделью и остальным. Он запускает цикл «рассуждение–действие»: запрашивает у модели следующее действие, вызывает инструмент и обрабатывает результат или ошибку.

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

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

Инструменты и действия

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

Модель запрашивает действие, например «запусти pytest» или «замени строку 8 в budget.py». Инструмент выполняет его и возвращает наблюдение — например, вывод тестов или обновлённый файл.

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

Среда разработки

Инструменты не запускаются на вашей машине. Они работают в песочнице.

В варианте с Docker OpenHands запускает сервер агента в отдельном контейнере. Поэтому в статье монтируется Docker‑сокет — контейнеру приложения он нужен, чтобы поднимать песочницы.

Песочница необязательно локальная. Агенты также могут работать во временных рабочих пространствах, например в Docker или Kubernetes, а Agent Server предоставляет выполнение, инструменты и рабочие пространства через REST‑ и WebSocket‑API. Логика агента одинакова независимо от места запуска песочницы.

Репозиторий

Репозиторий — это то, над чем работает агент. Он попадает в песочницу одним из двух способов: локальная папка, как в статье, или репозиторий, подключённый через интеграции GitHub, GitLab или Bitbucket.

Репозиторий также может подсказывать агенту, как себя вести. Файл AGENTS.md в корне добавляется в системный промпт в начале диалога. Более узкие инструкции располагаются в .agents/skills/, где агент сначала видит краткое содержание и загружает полный текст только при необходимости.

Сюда имеет смысл поместить правила проекта, которые агент не сможет угадать, например: «тесты запускаем make test, а не pytest».

Человеческая проверка

Последняя часть архитектуры — это вы.

OpenHands поддерживает три политики подтверждения: одобрять каждое действие, не одобрять ничего или одобрять только рискованные действия. Последний вариант зависит от анализатора безопасности, который помечает каждое действие как LOW, MEDIUM, HIGH или UNKNOWN по риску. По умолчанию включён NeverConfirm, поэтому агент работает без остановок, если вы это не измените.

Второй контрольный пункт — в конце. Работа агента не завершена, пока вы не прочитаете diff и не проверите результаты тестов.

Рабочие процессы в OpenHands

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

Общее у таких задач то, что они состоят из нескольких шагов. Вот шесть типов работ, где уместен цикл агента.

Исправление ошибок

Показанный в статье баг был виден в одном файле. В реальности так бывает редко.

Допустим, логи приложения показывают KeyError в продакшене, а стек‑трейс указывает на функцию в трёх вызовах от места, где приходят некорректные данные. Вы вставляете стек‑трейс в OpenHands и просите исправить.

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

Ищите именно тест‑воспроизведение. Он доказывает, что агент нашёл реальную причину, а не просто место проявления ошибки.

Реализация функциональности

Работа над фичами обычно затрагивает больше файлов, чем ожидаешь.

Допустим, скрипту отчёта в командной строке нужен флаг --since для фильтра операций по дате. Агент должен найти парсер аргументов, добавить флаг, передать значение в логику фильтрации и обновить справку. Затем он напишет тесты на новое поведение и обновит README.

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

Рефакторинг кода

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

Допустим, в проекте есть большой файл utils.py со вперемешку функциями для дат, строк и файлов. Вы просите OpenHands разбить его на три модуля.

Агент создаёт новые модули, переносит функции и обновляет импорты по всей кодовой базе. Он запускает тесты после каждого переноса. Так, если что‑то сломается, будет ясно, какой именно перенос стал причиной.

Написание тестов

Нетестированный код — распространённая отправная точка для работы агента: задача ясна и легко проверяема.

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

Если новый тест падает, агенту нужно решить: неправ тест или есть баг в коде. Это решение стоит проверить вручную.

Изучение существующих кодовых баз

Не каждая задача требует правок в коде.

Можно задавать OpenHands вопросы вроде: «Где это приложение валидирует пользовательский ввод до попадания в базу данных?» Агент ищет по кодовой базе, переходит по вызовам между файлами и отвечает с путями к файлам и ссылками на строки.

Это удобно, когда вы присоединяетесь к новому проекту или возвращаетесь к коду, который не трогали месяцами. Для работы «только чтение» примонтируйте репозиторий с режимом :ro вместо :rw, чтобы агент ничего не смог изменить даже случайно.

Запуск и отладка приложений

Некоторые ошибки проявляются только при запуске приложения.

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

Затем он исправляет код, перезапускает сервер и отправляет тот же запрос снова. Если ответ всё ещё неверный, цикл продолжается.

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

OpenHands и другие ИИ‑агенты для программирования

OpenHands — не единственный инструмент, способный взять задачу и пройти её самостоятельно. У Claude Code, Cursor и GitHub Copilot теперь тоже есть агентные функции, но они заметно различаются.

OpenHands vs Claude Code

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

Первое отличие — владение. Каждый публичный репозиторий OpenHands имеет собственную открытую лицензию, и вы можете читать, изменять и развёртывать всё самостоятельно. Claude Code — проприетарный инструмент агентного программирования от Anthropic, доступный в терминале, IDE, десктопном приложении и браузере.

Отсюда вытекает вопрос моделей. Claude Code построен вокруг моделей Claude от Anthropic. OpenHands работает с любым провайдером, поддерживаемым LiteLLM, включая локальную настройку с Ollama из статьи.

Отличается и повседневный процесс. Claude Code начинался как терминальный инструмент, и многие разработчики до сих пор используют его именно так. OpenHands опирается на браузерный интерфейс, а его CLI функционально завершён, но поддерживается в первую очередь ради стабильности.

Оба инструмента позволяют управлять поведением агента. Claude Code читает CLAUDE.md, настройки, хуки, навыки, команды и субагенты из директории .claude. OpenHands читает AGENTS.md и навыки из репозитория, а SDK позволяет строить собственных агентов на Python.

Автономность реализована по‑разному. Claude Code управляет использованием инструментов с помощью режимов разрешений, хуков и списков allow/deny и может изолировать команды. OpenHands по умолчанию запускает все команды внутри Docker‑песочницы и добавляет сверху политики подтверждения.

Вкратце: Claude Code — это отполированное решение «установил и работай», а OpenHands требует больше настройки и даёт больше контроля взамен. Они не взаимоисключающие: Agent Canvas может запускать Claude Code как агента вместо агента OpenHands по умолчанию.

OpenHands vs Cursor

Cursor — это ИИ‑редактор кода. OpenHands — платформа агентов. Это главное отличие, и большинство других различий вытекают из него.

В Cursor вы работаете внутри редактора, а агент — рядом с вами. Вы видите изменения в файлах, принимаете или отклоняете их и продолжаете писать. В OpenHands вы описываете задачу, агент работает в песочнице, а вы проверяете результат. GUI включает представление VS Code в песочницу, но основная работа происходит не там.

Доступ к репозиторию соответствует этому разделению. Агент Cursor работает с кодом, открытым в вашем редакторе. OpenHands — с тем, что примонтировано в его песочницу или подключено через Git‑интеграцию.

Разрыв меньше с Cloud Agents в Cursor. Они работают без присмотра в облаке и возвращают результат через ветки и pull‑запросы; для этого нужен подключённый аккаунт GitHub, GitLab, Azure DevOps или Bitbucket и платный план. Это близко к тому, что делает OpenHands, но на инфраструктуре Cursor.

Расширяемость — главное различие. Cursor поддерживает MCP‑серверы и правила проекта, но и редактор, и агент — закрытые продукты. В OpenHands вы можете менять самого агента, разворачивать его где угодно и запускать на локальной модели.

OpenHands vs GitHub Copilot

GitHub Copilot начинался как инструмент автодополнения в редакторе и оттуда дорос до агентных функций. OpenHands изначально создавался как агент.

Главная сила Copilot — там, где он живёт. Он работает внутри VS Code и IDE JetBrains, а его облачный агент напрямую — в GitHub. У OpenHands нет столь глубокой интеграции с IDE.

Для задач на уровне репозитория ближе всего облачный агент Copilot. Вы назначаете ему issue, и он работает в собственной временной среде разработки на базе GitHub Actions, где может запускать тесты и линтеры до пуша. OpenHands Cloud делает нечто подобное, когда вы упоминаете @openhands в комментарии к issue или pull‑запросу.

Платформа — главное отличие. Облачный агент Copilot доступен во всех платных планах Copilot в репозиториях на GitHub. OpenHands работает с GitHub, GitLab, Bitbucket или локальной папкой и может запускаться на вашем «железе», если вы этого хотите.

Copilot позволяет выбрать модель для задачи, но только из тех, что предлагает GitHub. У OpenHands такого ограничения нет.

Краткое сравнение:

Сравнение OpenHands с другими AI‑агентами

OpenHands для команд разработки ПО

Для одного разработчика OpenHands — это инструмент, который вы открываете по мере необходимости. Для команды это иначе.

Большинство команд уже организуют работу вокруг задач (issues), и OpenHands Cloud встраивается в этот процесс. Он интегрируется с GitHub, GitLab и Bitbucket, а также со Slack, Jira и Linear. Можно упомянуть @openhands в комментарии к issue или pull‑запросу, и агент подхватит задачу.

Есть и работа, о которой никто не просит, но она нужна всем. Автоматизации в Agent Canvas запускаются по расписанию или по вебхукам. Например, команда может использовать общий Agent Server для code‑review и обновлений зависимостей, в то время как каждый разработчик запускает личных агентов у себя на ноутбуке.

Тестирование работает так же, как в статье. Агент запускает тестовый набор в своей песочнице до отчёта о результатах. Но запуск в песочнице не заменяет CI — ваш конвейер всё равно запускается на каждый pull‑запрос, как и для кода, написанного людьми.

Отдельная тема — pull‑запросы. При работе OpenHands Cloud с GitHub он запрашивает краткоживущие токены, истекающие через восемь часов, с правами чтения и записи для содержимого, задач, pull‑запросов и рабочих процессов. В само‑хостинговых Enterprise‑средах агент использует авторизацию GitHub того пользователя, который его запустил, чтобы каждое изменение имело ответственного.

Именно так и должна работать ответственность. Агент может открыть pull‑запрос, но одобряет его разработчик. Защита веток и обязательные ревью применяются к pull‑запросам агента так же, как и ко всем остальным.

Изолированные среды позволяют масштабировать всё это. Каждая задача выполняется в собственной песочнице, поэтому два агента, исправляющие два бага, не перезаписывают файлы друг друга и не спорят за один и тот же порт.

Безопасность и песочницы в OpenHands

Инструмент автодополнения всегда лишь предлагает текст, а вы решаете, принимать его или нет.

Агент — другое дело. Он сам проходит по проекту, выполняет команды, устанавливает пакеты и правит файлы — часто не спрашивая. Поэтому вопрос меняется с «правилен ли этот код?» на «что агент запустил, чтобы к этому прийти?»

Изолированные среды выполнения

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

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

Права на репозиторий

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

Монтируйте только тот проект, над которым вы работаете, никогда — домашний каталог. Для задач «только чтение», например для изучения кода, используйте режим :ro . В Git‑интеграциях давайте агенту доступ только к нужным репозиториям и ни к чему больше.

Секреты и учётные данные

Если вы предоставляете креды — ключи API или токены — агент может их использовать. И агент, который может прочитать секрет, может также вывести его в лог или отправить куда‑то.

Поэтому не монтируйте папки с файлами .env, где лежат продакшн‑ключи. Давайте агенту тестовые креды с ограниченными правами и часто их ротируйте.

Сетевой доступ

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

Это открывает дверь для инъекций промптов. Веб‑страница или комментарий к задаче могут содержать инструкции, которым агент последует. GitHub снижает этот риск для своего облачного агента файрволом, ограничивающим интернет‑доступ по умолчанию; стоит подумать о подобных ограничениях и для вашего OpenHands.

Выполнение команд

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

У опции «рискованные действия» есть нюанс. Анализатор безопасности LLM по умолчанию использует уровень риска, который модель присваивает собственным действиям. Модель может пометить разрушительную команду как LOW, и она выполнится без запроса. Анализатор классифицирует риск для слоя политики — он сам по себе ничего не блокирует, и в документации рекомендуют сочетать его с изоляцией Docker.

Проверка сгенерированных изменений

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

Читайте полный diff, а не только файлы, которые ожидали изменений. Особое внимание — конфигурации CI, файлам зависимостей и скриптам. В OpenHands Cloud токен GitHub агента имеет права записи для workflows, поэтому изменения в .github/workflows могут изменить то, что запускается в вашем пайплайне.

Ограничения OpenHands

Код, который пишет OpenHands, всё ещё может содержать ошибки. Прохождение тестов лишь говорит, что код соответствует тестам, и агент может написать и то, и другое. Если тесты слабые, код может пройти и всё равно быть неверным.

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

С сильной облачной моделью OpenHands хорошо справляется с задачами на несколько файлов. С маленькой локальной моделью вы увидите провальные вызовы инструментов и ответы в духе чат‑бота, а некоторые локальные модели, даже с большим окном контекста, не умеют надёжно пользоваться инструментами.

Агентные циклы также дороже, чем чат. На каждом шаге вся история разговора снова отправляется в модель, а долгие задачи занимают много шагов. В документации OpenHands предупреждают, что агент отправляет много запросов LLM, и рекомендуют лимиты затрат и мониторинг использования. Конденсер контекста помогает, но он суммирует старые шаги, поэтому детали могут теряться в длинных задачах.

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

И каждое изменение всё равно должен одобрить человек. Всегда держите это в уме.

OpenHands и будущее ИИ‑агентов для программирования

Инструменты ИИ для программирования прошли путь от автодополнения к чату и далее к агентам, решающим целые задачи. OpenHands — один из проектов, которые продвигают этот последний шаг.

Направление легко увидеть по индустрии. Cursor описывает новую эпоху, где автономные облачные агенты берут на себя более крупные задачи на более длительные сроки. Copilot теперь забирает задачи из GitHub и Linear. Claude Code работает в терминале, браузере и Slack.

У открытых платформ особая роль в этом переходе. С OpenHands вы можете изучить, как работает агент, запустить его на собственной инфраструктуре и выбрать модель. Для команд с жёсткими правилами по данным это часто единственный допустимый способ использования агентов.

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

Вывод

Главное отличие OpenHands от конкурентов — контроль. Вы можете читать исходники, хостить на своём оборудовании и запускать с любой моделью, включая локальную. Более «плотно упакованные» коммерческие инструменты — Claude Code, Cursor и GitHub Copilot — дают более гладкий опыт, но на своих условиях.

Но агент с доступом к вашему терминалу и репозиториям всё равно нуждается в человеческой проверке. Всегда читайте diff и запускайте тесты сами.

Если хотите узнать, как создать агента с нуля, посмотрите наш вебинар Introduction to Creating AI Agents in Python.