Open-Interpreter: руководство по открытым ИИ-агентам для программирования

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

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

Open Interpreter решает это, эмулируя обвязку, под которую настраивали каждую модель, например Claude Code или Kimi Code. Это открытый ИИ-агент для программирования, запускаемый из терминала; текущая версия — проект на Rust, созданный на базе Codex от OpenAI, а не знакомый вам ранее «компьютерный ассистент» на Python.

В этой статье мы пройдём установку, настройку модели и обвязки, практический рабочий процесс и сравнение Open Interpreter с Claude Code, OpenCode и Codex.

Вы новичок в ИИ-агентах? Запишитесь на наш курс Introduction to AI Agents и освоите основы за один день.

Что такое Open Interpreter?

Open Interpreter даёт модели ИИ доступ к вашему проекту и инструментам, которыми пользуется разработчик.

Достаточно описать задачу простым английским — и агент начнёт работу с вашим кодом. Он умеет работать с:

• Файлами: читает ваш код и редактирует его
• Командами: запускает shell-команды, скрипты и сборочные шаги
• Репозиториями: работает с Git, может смотреть историю проекта и показывать diff своих изменений
• Инструментами разработки: использует тест-раннеры и линтеры, чтобы проверять свою работу
• Многошаговыми задачами: связывает эти действия — от первичного анализа до протестированного исправления

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

По состоянию на сентябрь 2026 года у основного репозитория более 68 000 звёзд на GitHub.

Как работает Open Interpreter

Open Interpreter работает в цикле:

1. Задача: вы описываете, что нужно, например «исправь падающий тест»
2. Инспекция: модель читает структуру проекта и релевантные файлы
3. Планирование: решает, какие инструменты или действия нужны для задачи
4. Правки: читает или меняет файлы
5. Команды: запускает shell-команды, например тестовый набор
6. Оценка: проверяет вывод, чтобы понять, сработало ли изменение
7. Итерация: повторяет шаги 2–6, пока задача не будет выполнена или не потребуется ваш ввод

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

Вот более наглядный обзор:

Как работает Open Interpreter

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

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

Как установить Open Interpreter

Open Interpreter устанавливается как автономный бинарник, поэтому вам не нужны Python или pip.

Если где-то в старом блоге вам предлагают выполнить pip install open-interpreter, речь идёт о легаси-версии на Python. Эта команда не установит рассматриваемый здесь агент на Rust.

Также пригодится Git. Open Interpreter работает и без него, но с Git у него будет сессия с учётом репозитория и диффы.

macOS и Linux

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

curl -fsSL https://www.openinterpreter.com/install | sh

Скрипт скачает релиз для вашей платформы и поместит команду interpreter в ~/.local/bin.

Windows

Откройте PowerShell и выполните:

irm https://www.openinterpreter.com/install.ps1 | iex

Поддерживается и WSL, если вам ближе Linux-окружение. В этом случае запустите команду для macOS и Linux из терминала WSL.

Проверка установки

Перезапустите терминал, чтобы обновился PATH, затем проверьте версию:

interpreter --version

Если вы видите номер версии — установка прошла успешно.

Проверка версии Open Interpreter

Запуск интерактивной сессии

Запустите сессию из любого каталога:

interpreter

Можно ввести и просто i — это короткий алиас той же команды.

Open Interpreter откроет терминальный интерфейс, где вы описываете задачи простым английским. При первом запуске он попросит подключить провайдера модели. В следующем разделе мы используем локальную модель через Ollama, так что пока этот шаг можно пропустить.

Интерактивная сессия Open Interpreter

Чтобы выйти из сессии, введите /exit.

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

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

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

Создайте демо-проект

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

Начните с папки проекта и виртуального окружения:

mkdir habit-tracker && cd habit-tracker
python3 -m venv .venv
source .venv/bin/activate
pip install pytest

Создайте habits.py со следующим кодом:

def longest_streak(dates):
    """Return the longest run of consecutive days.

    Each date is a 'YYYY-MM-DD' string, for example "2026-03-14".
    Duplicate dates count once.
    """
    days = sorted(set(dates))
    if not days:
        return 0

    longest = current = 1
    for previous, today in zip(days, days[1:]):
        if int(today[8:10]) - int(previous[8:10]) == 1:
            current += 1
            longest = max(longest, current)
        else:
            current = 1
    return longest

Затем создайте test_habits.py:

from habits import longest_streak


def test_streak_within_one_month():
    dates = ["2026-03-01", "2026-03-02", "2026-03-03", "2026-03-10"]
    assert longest_streak(dates) == 3


def test_duplicate_dates_count_once():
    dates = ["2026-03-01", "2026-03-01", "2026-03-02"]
    assert longest_streak(dates) == 2


def test_streak_across_month_boundary():
    dates = ["2026-01-30", "2026-01-31", "2026-02-01"]
    assert longest_streak(dates) == 3

В функции есть ошибка. Мы не будем её указывать — это задача агента.

Добавьте файл .gitignore, чтобы виртуальное окружение и кэши не попали в репозиторий:

.venv/
__pycache__/
.pytest_cache/

Теперь зафиксируйте проект:

git init
git add .
git commit -m "Initial commit"

Этот коммит даст «чистую» точку отсчёта. Позже вы сможете увидеть, что именно агент изменил.

Запустите тесты, чтобы подтвердить наличие бага:

python -m pytest

Результат тестов трекера привычек

Два теста проходят, один падает. Это проблема, которую должен решить Open Interpreter.

Запустите Open Interpreter с локальной моделью

Вам понадобится установленный и запущенный Ollama. Нужна и модель с поддержкой вызова инструментов — скачайте её:

ollama pull qwen3-coder:30b

Затем запустите Open Interpreter из папки проекта. Используйте тот же терминал, чтобы агент мог применить pytest из вашего виртуального окружения:

interpreter --oss --local-provider ollama -m qwen3-coder:30b

Что делает каждый флаг:

• --oss: использует локального open source-провайдера

• --local-provider ollama: выбирает Ollama вместо LM Studio

• -m qwen3-coder:30b: задаёт модель для этого запуска

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

Сессия Open Interpreter с локальной моделью Ollama

Попросите изучить баг

Пока вы не хотите, чтобы агент что-то редактировал. Сначала запросите диагностику:

The tests in this project are failing. Find the cause and explain how you'd fix it. Don't edit any files yet.

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

Вывод Open Interpreter

Проверьте предлагаемое исправление

Прочитайте объяснение перед любым одобрением.

Правильная диагностика укажет, что функция сравнивает только число дня в месяце, из‑за чего серия обрывается при переходе в новый месяц. Хорошее исправление сравнивает полные даты, например с помощью date.fromisoformat() из модуля datetime в Python.

Если диагноз неверный, скорректируйте его в той же сессии до того, как агент что-либо отредактирует.

Предложение исправления от Open Interpreter

Разрешите правку файла и запуск тестов

Когда вы довольны планом, примените исправление:

Apply the fix to habits.py, then run the tests.

Агент отредактирует файл и перезапустит pytest. Вы хотите увидеть, что все три теста проходят.

Все тесты проходят после исправления

Проверьте diff

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

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

Diff изменений, внесённых Open Interpreter

Точный diff зависит от модели, так что ваш может отличаться строка в строку. Если изменение нравится — закоммитьте его, если нет — восстановите исходный файл:

git restore habits.py

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

Модели в Open Interpreter

Open Interpreter предполагает, что вы приносите свою модель.

Каждый запрос проходит через три слоя:

Слои запроса

Вот что вы можете подключить:

• Хостинговые модели: коммерческие модели от провайдеров вроде OpenAI и Anthropic — со входом или API‑ключом
• Модели с открытыми весами через API: такие как Kimi K3 и DeepSeek — либо у их провайдеров, либо через шлюзы вроде OpenRouter
• Локальные модели: модели, запускаемые на вашем оборудовании через Ollama или LM Studio — это встроенные провайдеры, не требующие API‑ключа

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

Обратите внимание на ollama-cloud. Это отдельный хостинговый провайдер, поэтому ваши запросы уходят с машины. Только встроенный провайдер ollama запускает модели локально.

Переключение моделей

Модель можно менять на трёх уровнях:

• Внутри сессии: выполните /model, чтобы выбрать провайдера, модель и усилие рассуждения

• Для одного запуска: передайте флаг -m, как в предыдущем разделе

• По умолчанию: укажите в конфиге

Вы можете выполнить /status в любой момент, чтобы увидеть активные провайдера и модель.

Настройка провайдера

Open Interpreter читает настройки из ~/.openinterpreter/config.toml. Чтобы сделать конфигурацию с Ollama из предыдущего раздела дефолтной, добавьте две строки:

model_provider = "ollama"
model = "qwen3-coder:30b"

После этого interpreter запускается с этой моделью, и флаги не нужны.

Хостинговые провайдеры читают API‑ключи из переменных окружения. Например, для DeepSeek нужна DEEPSEEK_API_KEY:

export DEEPSEEK_API_KEY="your-api-key"

Можно также добавить любой совместимый с OpenAI endpoint как кастомного провайдера:

model_provider = "my-provider"
model = "my-model"

[model_providers.my-provider]
name = "My Provider"
base_url = "https://api.example.com/v1"
env_key = "MY_PROVIDER_API_KEY"
wire_api = "chat"

Параметр wire_api указывает Open Interpreter, какой формат запроса ждёт endpoint. Используйте chat для совместимых с OpenAI Chat Completions, responses для OpenAI Responses API и messages для эндпоинтов в стиле Anthropic.

Доверенный проект также может иметь свой .openinterpreter/config.toml, который переопределит пользовательский конфиг. Флаги командной строки переопределяют оба. Если не уверены, что «победит», выполните /debug-config, чтобы увидеть эффективные настройки и их источник.

Почему важны и модель, и обвязка

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

Нужны обе. Хорошая модель в неподходящей обвязке шлёт некорректные вызовы инструментов и неверно читает результаты. И хорошая обвязка не спасёт модель, которая не понимает код.

Поэтому Open Interpreter выбирает обвязку вместе с моделью. Например:

• Модели Claude получают обвязку claude-code

• Kimi — kimi-code

• Qwen — qwen-code

• DeepSeek — claude-code-bare

Для других семейств моделей вы можете выбрать обвязку сами через /harness.

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

Обвязки агента в Open Interpreter

Эмуляция обвязок — главная причина существования текущей версии Open Interpreter.

Обвязка агента — это всё вокруг модели, что превращает её в агента. Включает:

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

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

В Open Interpreter есть набор встроенных режимов обвязки. Чаще всего вы будете использовать:

• native: собственная обвязка Open Interpreter, унаследованная от Codex

• claude-code: эмулирует подсказки и инструменты Anthropic Claude Code

• kimi-code: реализация на Rust обвязки Kimi Code, рекомендованной Moonshot для моделей Kimi

• qwen-code: эмуляция CLI Alibaba Qwen Code для моделей Qwen

• swe-agent: эмуляция SWE-agent — исследовательского агента для решения GitHub-issues

В полном списке также есть варианты вроде claude-code-bare, kimi-cli, deepseek-tui, zcode и minimal. Выполните /harness в сессии, чтобы увидеть, что поддерживает ваша версия.

Вы можете переключать обвязки прямо в сессии через /harness или задать значение по умолчанию в ~/.openinterpreter/config.toml:

harness = "kimi-code"
harness_guidance = true

Параметр harness_guidance добавляет надёжные указания там, где это допускает обвязка. Установите false для более строгой эмуляции. Если harness не задан, Open Interpreter выберет её на основе семейства модели, как вы видели ранее.

Почему важна обвязка

Большинство вендоров настраивают свои модели программирования внутри конкретной агентной конфигурации и публикуют рекомендованную обвязку.

Модель привыкает к этой обвязке: к стилю подсказок, названиям инструментов, формату правок файлов и способу возврата результатов.

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

С результатами инструментов так же: если обвязка возвращает результаты в непривычном формате, модель их неправильно читает. Если обвязка удаляет рассуждения модели между ходами, «думающая» модель теряет свой план.

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

Флагманские модели чаще «восстанавливаются» в непривычной обвязке, но меньшие и дешёвые — обычно нет. Open Interpreter не загоняет все модели в один формат, а подстраивает формат под модель.

Вы можете проверить это на демо‑проекте. Восстановите исходный файл через git restore habits.py, переключите обвязку через /harness и дайте агенту ту же подсказку. Затем сравните, сколько шагов потребуется и как он форматирует правки.

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

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

Работа с учётом репозитория

Open Interpreter работает внутри вашего Git‑репозитория. Он читает структуру проекта и отслеживает свои изменения.

Здесь помогают две слэш‑команды. /diff показывает изменения рабочего дерева, а /review просит агента проверить текущие изменения на баги и регрессии перед коммитом. Тот же обзор можно запустить без сессии:

interpreter exec review --uncommitted

Сессии тоже сохраняются. Если вы остановились посреди задачи, interpreter resume --last продолжит с того же места.

Терминал и выполнение команд

Агент запускает те же команды, что и вы: тестовые наборы, линтеры, сборку, менеджеры пакетов. Всё это работает внутри нативной песочницы на macOS, Linux и Windows.

Долгоиграющие команды можно запустить в фоне. Используйте /ps для списка и /stop для остановки.

Для скриптов и CI режим interpreter exec выполняет задачу без интерактивного интерфейса:

interpreter exec "fix the failing test"

Гибкость по моделям

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

Здесь полезны профили. Допустим, вы хотите недорогую модель для рутины и более сильную — для код‑ревью. Их можно определить в конфиге:

[profiles.review]
model_provider = "deepseek"
model = "deepseek-v4-pro"
sandbox_mode = "read-only"

Затем запускайте interpreter --profile review, когда это нужно.

Переключение обвязок

/harness меняет то, как модель видит задачу, не меняя саму модель. Это первое, что стоит попробовать, если у модели проблемы с вызовами инструментов, прежде чем переходить на более крупную модель.

MCP и инструменты

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

[mcp_servers.docs]
command = "npx"
args = ["-y", "your-docs-mcp-server"]
default_tools_approval_mode = "prompt"

Выполните /mcp, чтобы увидеть настроенные серверы и их инструменты. Параметр default_tools_approval_mode заставляет агента спрашивать разрешение перед использованием инструмента этого сервера.

Работает и наоборот. interpreter mcp-server публикует Open Interpreter как MCP‑сервер, а interpreter acp запускает его внутри редакторов с поддержкой Agent Client Protocol — открытого стандарта подключения редакторов к агентам программирования.

Skills и AGENTS.md

AGENTS.md — это Markdown‑файл в вашем репозитории с правилами проекта, которые агент читает при каждой задаче. Для трекера привычек он может выглядеть так:

# AGENTS.md
- Run the tests with python -m pytest before you finish a task.
- Use the Python standard library only. Don't add new dependencies.

Можно также выполнить /init, и агент напишет первую версию за вас.

Skills — это переиспользуемые рабочие процессы, упакованные в папки в .agents/skills внутри проекта или ~/.agents/skills для пользователя. Агент подхватывает skill автоматически, если задача ему соответствует. Выполните /skills, чтобы увидеть доступные.

Оба формата общие, так что одни и те же файлы работают и с другими агентами программирования, которые их поддерживают. Open Interpreter также поддерживает хуки, которые запускают ваши команды в определённые моменты сессии. Вы просматриваете и доверяете им через /hooks.

Песочница и одобрения

Два параметра управляют тем, что агент может делать:

• Режим песочницы: read-only, workspace-write или danger-full-access

• Политика одобрений: untrusted, on-request или never

Песочница определяет, что возможно, а политика одобрений — когда агент сначала спрашивает. С workspace-write и on-request агент может редактировать проект и запускать тесты, но просит разрешение на доступ сверх этого.

Оба параметра можно менять через /permissions или флагами -s и -a. Есть и флаг --yolo, который отключает и песочницу, и одобрения — в документации он помечен как опасный. Подробности — в разделе безопасности.

Open Interpreter для локальных и открытых моделей

Open Interpreter позиционирует себя как агент для программирования, ориентированный на недорогие модели.

Крупнейшие проприетарные агенты строятся вокруг собственных моделей вендоров. Open Interpreter даёт один агент, который работает с проприетарными, хостинговыми моделями с открытыми весами и локальными моделями.

Модели с открытыми весами

У моделей Kimi, DeepSeek, GLM и Qwen публичные веса. Ими можно пользоваться через стороннего провайдера или на своём оборудовании.

Это даёт два плюса. Хостинговые модели с открытыми весами обычно дешевле на токен, чем флагманские проприетарные. И вы не ограничены одним хостом, потому что одна и та же модель работает там, где доступны её веса.

В Open Interpreter есть отдельные руководства для провайдеров Kimi K3, DeepSeek и GLM. Для этих семейств моделей он также выбирает подходящую обвязку.

Локальный инференс

Ollama и LM Studio — встроенные провайдеры, так что вы можете запускать модель на своём компьютере без API‑ключа и оплаты за токены.

Цена — это «железо». В моём тесте devstral-small-2 на MacBook Pro M1 Max с 64 ГБ объединённой памяти сама модель заняла 26 ГБ. Окон контекста по умолчанию в Ollama оказалось мало для цикла агента, а при 128k токенов использование памяти то росло, то падало, пока сессия не застопорилась.

Агентам для программирования нужно большое окно контекста: системная подсказка, определения инструментов, содержимое файлов и вывод команд должны поместиться. Ollama рекомендует минимум 64k токенов для агентов в стиле Codex. А большее окно контекста выберет ещё больше памяти сверх модели.

Стоимость и приватность

Open Interpreter работает на вашей машине, но модель может работать не на ней.

Куда уходит ваш код, зависит от провайдера:

• Локальный провайдер: подсказки, содержимое файлов и вывод команд остаются на вашей машине
• Хостинговый провайдер: всё это уходит на серверы провайдера, даже если модель — с открытыми весами

Ваш конфиг, сессии и логи всегда хранятся локально в ~/.openinterpreter.

Если нужно больше контроля, добавьте кастомного провайдера, указывающего на ваш сервер инференса. Подойдёт любой сервер с API, совместимым с OpenAI, например vLLM‑деплой на GPU вашей компании. Так вы получите хостинг у себя, но с собственной инфраструктурой.

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

Открытые модели по‑разному справляются с вызовом инструментов. Слабое использование инструментов проявляется в некорректных вызовах, зацикливаниях, ранних остановках или игнорировании вывода команд.

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

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

Краткое резюме вариантов:

Варианты Open Interpreter для локальных и открытых моделей

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

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

Open Interpreter vs. Claude Code

Claude Code — терминальный агент Anthropic. Первое отличие — владение: Claude Code — проприетарный, Open Interpreter — open source под Apache 2.0. Вы можете читать и менять любую часть Open Interpreter.

Второе — выбор модели. Claude Code создан для моделей Claude. Можно направить его на совместимые с Anthropic эндпойнты других провайдеров, но обвязка остаётся «под Claude». В Open Interpreter выбор модели — ключевая функция.

Сравнение обвязок самое интересное. Claude Code — одна из обвязок, которые эмулирует Open Interpreter. В режиме claude-code любая модель получает подсказки и инструменты в стиле Claude Code в среде Open Interpreter. UI и слэш‑команды остаются Open Interpreter, так что это не тот же продукт с другой моделью.

Оба инструмента — терминальные в первую очередь. У каждого есть интерактивная сессия и неинтерактивный режим для скриптов и CI. Для проектных инструкций Claude Code читает CLAUDE.md, а Open Interpreter — общий формат AGENTS.md.

У Claude Code экосистема больше: расширения для IDE, десктоп‑ и веб‑приложения, маркетплейс плагинов, субагенты, SDK. Open Interpreter моложе и опирается на открытые стандарты — MCP, skills, AGENTS.md, Agent Client Protocol — вместо собственной экосистемы.

Если вы работаете с моделями Claude и хотите максимально отполированный опыт, надёжнее выбрать Claude Code. Если хотите использовать другие модели или избегать проприетарных инструментов — выбирайте Open Interpreter.

Open Interpreter vs. OpenCode

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

Поддержка моделей на бумаге схожа. OpenCode поддерживает более 75 провайдеров, Open Interpreter генерирует список провайдеров из публичного каталога. Оба запускают локальные модели через Ollama.

Терминальный опыт отличается сильнее. У OpenCode собственный TUI с интеграцией Language Server Protocol (LSP), который возвращает в модель диагностические сообщения по коду, например ошибки типов. TUI Open Interpreter пришёл из Codex.

В конфигурации OpenCode использует файл opencode.json, а Open Interpreter — config.toml с профилями.

Главное отличие — архитектура агента. OpenCode работает по схеме «клиент–сервер»: TUI — один из клиентов локального сервера, к которому могут подключаться и другие клиенты. В нём есть встроенные агенты build и plan, поддерживаются кастомные агенты и субагенты. Он подстраивает системную подсказку под семейство модели, но инструменты и цикл — свои. Open Interpreter идёт дальше и меняет всю обвязку, включая схемы инструментов и формат сообщений. В новых сборках даже есть режим обвязки opencode.

Со стороны разработки OpenCode — самостоятельный код, развиваемый командой и сообществом. Open Interpreter основан на форке Codex, поэтому значительная часть рантайма приходит из апстрима. Это компромисс: Open Interpreter «наследует» песочницу и рантайм Codex, а OpenCode контролирует весь стек.

Open Interpreter vs. Codex

Эти два инструмента не конкуренты в обычном смысле. Open Interpreter — форк Codex.

Они разделяют рантайм на Rust, TUI, песочницу, одобрения, AGENTS.md, skills, MCP, режим exec и большинство слэш‑команд. Когда я запускал Open Interpreter, подсказка о возобновлении сессии ещё говорила codex resume.

Codex — агент OpenAI, построенный вокруг моделей OpenAI. Он поддерживает локальные модели через --oss и кастомные провайдеры, но опыт по умолчанию ориентирован на OpenAI.

Open Interpreter расширяет Codex в нескольких направлениях:

• Эмуляция обвязок: меняет подсказки, схемы инструментов и формат сообщений под каждое семейство моделей

• Поддержка провайдеров: сгенерированный каталог провайдеров и отдельные гайды для Kimi K3, DeepSeek и GLM

• Chat Completions: флаг --chat-completions запускает любого провайдера, совместимого с OpenAI

• Override SDK Codex: приложения на SDK Codex могут выполняться через Open Interpreter

Open Interpreter также хранит конфиг и сессии в ~/.openinterpreter, не конфликтуя с установкой Codex.

Если вы в основном используете модели OpenAI, лучше выбрать Codex. Если — другие модели, Open Interpreter даст тот же рабочий процесс с лучшей поддержкой именно их.

Краткое резюме:

Сравнение Open Interpreter с другими ИИ‑агентами для программирования

Безопасность и разрешения в Open Interpreter

Худшее, что может сделать чат-бот, — дать плохой ответ, который вы проигнорируете. Агент для программирования запускает команды на вашей машине, читает и пишет файлы и может выходить в сеть. Ошибочное решение модели или инъекция подсказки могут реально навредить. Инъекция подсказки — это инструкции, скрытые в читаемом агентом содержимом, например в README или на веб‑странице.

Open Interpreter наследует модель безопасности от рантайма Codex. В ней два слоя: песочница, ограничивающая возможности, и политика одобрений, решающая, когда агент сначала спрашивает вас.

Выполнение команд и доступ к файловой системе

Каждая команда агента проходит через песочницу на уровне ОС в macOS, Linux и Windows. Есть три режима песочницы:

• read-only: агент может читать файлы, но не менять их

• workspace-write: агент может редактировать файлы и выполнять команды внутри папки проекта

• danger-full-access: без песочницы

В режиме workspace-write запись файлов ограничена активным рабочим пространством. Агент может исправлять ваш код, но не может редактировать файлы вне проекта.

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

В режиме workspace-write команды по умолчанию не имеют сетевого доступа. Это блокирует загрузки и не даёт агенту отправлять ваш код куда-либо.

Иногда сеть нужна, например для установки пакета. Её можно включить в конфиге:

sandbox_mode = "workspace-write"

[sandbox_workspace_write]
network_access = true

Включайте только там, где это действительно нужно.

Одобрения

Политика одобрений решает, когда агент остановится и спросит:

• untrusted: спрашивает перед командами, которых нет в списке доверенных

• on-request: спрашивает, когда задаче нужен доступ шире песочницы

• never: никогда не спрашивает

Для проектов под контролем версий хороший дефолт — workspace-write с on-request. Агент работает внутри проекта и спрашивает, прежде чем выйти за его рамки. Git даёт возможность откатиться, если что-то пойдёт не так.

Флаг --yolo отключает и песочницу, и одобрения. Используйте только в «одноразовой» среде — контейнере или VM.

Учетные данные и секреты

Команды агента наследуют окружение вашей оболочки. Если ваши API‑ключи в переменных окружения, эти команды их увидят.

Это можно ограничить через shell_environment_policy:

[shell_environment_policy]
inherit = "core"
exclude = ["AWS_*", "*_TOKEN"]

Значение core передаёт только базовые переменные вроде HOME и PATH, а exclude исключает всё, что подходит под шаблоны.

Файлы — ещё один риск. Агент может прочитать файл .env в вашем проекте даже в режиме read-only. С хостинговым провайдером всё, что читает агент, уходит на серверы провайдера.

Помните: песочница ограничивает ущерб, но это страховка, а не гарантия.

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

Эволюция Open Interpreter

Если вы нашли статью об Open Interpreter, которая начинается с pip install, это не ошибка. Речь о другом проекте.

Оригинальный Open Interpreter запустился в 2023 как проект на Python. Он позволял языковым моделям выполнять Python, JavaScript и shell‑код на вашей машине, и его знали как опенсорс‑альтернативу Code Interpreter из ChatGPT. Поздние версии добавили управление компьютером — модель могла работать и с вашим рабочим столом.

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

Версия на Python не исчезла. Она продолжается как форк сообщества по адресу endolith/open-interpreter.

У обеих версий одно имя, общая история репозитория GitHub и одна команда interpreter, так что их легко перепутать.

Самый очевидный признак:

• pip install open-interpreter: легаси‑версия на Python

• curl или установщик PowerShell: текущая версия на Rust

Преимущества и ограничения Open Interpreter

Open Interpreter не всегда подходит под любой сценарий. Вот когда он уместен, а когда — нет.

Преимущества

• Открытый исходный код: лицензия Apache 2.0 — вы можете читать, аудировать и форкать весь код

• Выбор модели: используйте хостинговые, модели с открытыми весами и локальные — в одном агенте, переключая их прямо в сессии

• Несколько обвязок агентов: вы ближе к производительности, под которую модель настраивали — редкая возможность среди агентов

• Терминал‑нативная разработка: вписывается в ваш shell и Git‑процессы, а режим exec работает в скриптах и CI

• Открытые и более дешёвые модели: проект вокруг них и построен — с отдельными гайдами и соответствующими обвязками

• Расширяемость: MCP, skills, хуки, AGENTS.md, Agent Client Protocol и переопределение SDK Codex позволяют связать его с другими инструментами

Ограничения

• Качество моделей разнится: агент настолько хорош, насколько хороша модель, и никакая обвязка не исправит модель, не умеющую планировать

• Локальным моделям нужно серьёзное «железо»: в моих тестах один devstral-small-2 занял 26 ГБ памяти — без учёта большого окна контекста

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

• Выполнение команд — это риск: песочница и одобрения снижают его, но не убирают

• Код всё равно нужно ревьюить: проходящие тесты не гарантируют корректное исправление, придётся читать каждый diff

Вывод

Open Interpreter — опенсорс‑агент для программирования, который работает с выбранной вами моделью — хостинговой, с открытыми весами или локальной.

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

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

Если вы хотите получить сертификат инженера по ИИ, запишитесь на трек Associate AI Engineer for Developers и переходите в мир ИИ в удобном для вас темпе.