TrendShift 딥다이브 · 2026-07-17 · Daily #10

openinterpreter/openinterpreter 딥다이브
— 전설의 Open Interpreter가 Rust로 다시 태어나다

Open Interpreter는 원래 파이썬으로 짠 "컴퓨터를 위한 자연어 인터페이스"로 2023년 GitHub을 휩쓴 스타 프로젝트였다. 그런데 이 저장소는 파이썬 코드를 통째로 버리고, OpenAI의 코딩 에이전트 Codex(Rust 버전)를 하드포크해 다시 태어난 새 몸이다. 새 정체성은 단 한 줄 — "저비용 모델에 최적화된 코딩 에이전트". 명령어는 i 혹은 interpreter다. 진짜 핵심은 하니스 에뮬레이션(harness emulation)이라는 발상이다. DeepSeek·Kimi·Qwen·GLM 같은 값싼 모델을, 그 모델이 강화학습으로 훈련받은 바로 그 "하니스"(시스템 프롬프트+도구 포맷+와이어 규격)로 감싸 최고 성능을 끌어낸다. 전체는 Rust 워크스페이스 98개 크레이트 · 약 116만 줄. 이 문서는 소스를 직접 클론해 "여기서 무엇을 배울 수 있는가"를 파고든다. (저장소: openinterpreter/openinterpreter · OpenAI Codex의 하드포크 · Rust edition 2024 · Apache-2.0 · 제품 버전 0.0.28 · 최신 커밋 2026-07-17 e79e546 · TrendShift Daily #10 · #AI agent)
목차
  1. 프로젝트 한 줄 요약
  2. 왜 지금 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 · 크레이트 구조 해부
  6. 학습 포인트
  7. 시스템 · 실행 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한 줄 요약

이름의 반전 — "Open Interpreter"라는 껍데기 안에 사실은 OpenAI Codex가 들어 있다

openinterpreter/openinterpreter"저비용 모델로도 잘 도는, 터미널 안에서 사는 코딩 에이전트"다. 당신이 "이 버그 고쳐줘"라고 자연어로 치면, 에이전트가 스스로 셸을 돌리고(shell_command) 파일을 고쳐(apply_patch) 결과를 화면에 실시간으로 흘려준다. 이 "생각→도구 호출→관찰→다시 생각"의 반복(에이전트 루프)이 심장이다. 여기까지는 요즘 흔한 터미널 코딩 에이전트와 같다. 다른 점은 그 껍데기 아래의 정체와, "저비용 모델"이라는 목표다.

가장 먼저 알아야 할 사실: 이 저장소는 OpenAI의 Codex(codex-rs)를 통째로 하드포크한 것이다. 파일을 열어 보면 크레이트 이름이 전부 codex-*이고 디렉토리도 codex-rs/다. README가 이를 정직하게 밝힌다 — "Open Interpreter is a fork of OpenAI's Codex." 원래의 파이썬 Open Interpreter는 어디 갔을까? README 하단에 답이 있다: "원조 파이썬 프로젝트는 커뮤니티가 유지하는 endolith/open-interpreter로 계속 산다." 즉 이 이름을 물려받은 새 프로젝트는 완전히 다른 코드베이스(파이썬→Rust)로 재출발한 셈이다.

핵심 용어 · 이 프로젝트의 정체
하드포크 (hard fork) · Codex
Codex는 OpenAI가 만든 터미널 코딩 에이전트(원래는 codex-rs라는 Rust 프로젝트)다. 하드포크란 남의 저장소를 통째로 복제해 와, 이후엔 독자적으로 발전시키는 것을 말한다. Open Interpreter는 Codex의 방대한 Rust 코드(98개 크레이트)를 그대로 가져온 뒤, 그 위에 "하니스 에뮬레이션"이라는 얇은 레이어 하나를 얹어 "저비용 모델용"으로 리브랜딩했다. 그래서 이 문서를 읽을 때 코드 곳곳의 codex 네이밍에 놀라지 말자 — 혈통이 Codex이기 때문이다. 라이선스도 Apache-2.0을 그대로 이어받았고, NOTICE 파일엔 "OpenAI Codex, Copyright 2025 OpenAI" 저작권 고지가 의무적으로 보존돼 있다.
핵심 용어 · 제품의 진짜 무기
하니스 에뮬레이션 (harness emulation)
하니스(harness)란 LLM을 감싸는 "마구" — 시스템 프롬프트, 도구를 부르는 포맷, API 와이어 규격을 한 세트로 묶은 껍데기다. 요즘 모델들은 각자 특정 하니스(예: Claude는 Claude Code, Kimi는 Kimi CLI)에 맞춰 강화학습으로 튜닝돼 있어서, 다른 하니스에 끼우면 실력이 확 떨어진다. Open Interpreter의 핵심 아이디어는 저비용 모델(DeepSeek·Kimi·Qwen·GLM)을, 그 모델이 원래 훈련받은 하니스를 흉내 내(emulate) 감싸는 것이다. Kimi 모델을 쓰면 "당신은 Kimi Code CLI입니다"로 시작하는 프롬프트와 Kimi식 도구 포맷을 자동으로 입혀 준다. "싼 모델에 비싼 하니스의 옷을 입혀 성능을 끌어낸다" — 이것이 이 프로젝트가 파는 진짜 상품이다.
한 문장 비유

"명문 구단 유니폼을 입혀 주는 저가 선수 스카우트 — 싼 모델도 자기가 뛰던 전술판에 세우면 제 실력이 나온다"

실력 있지만 저평가된 선수(저비용 모델)를 데려와도, 낯선 팀 전술에 넣으면 헤맨다. Open Interpreter는 그 선수가 원래 뛰던 구단의 유니폼과 전술판(하니스)을 그대로 입혀 실전에 세운다. Kimi 선수에겐 Kimi 전술을, DeepSeek 선수에겐 DeepSeek 전술을. 몸통(에이전트 엔진)은 OpenAI Codex에서 빌려 온 튼튼한 것을 쓰되, 선수마다 옷만 갈아입히는 것이 승부수다.

그리고 이 스카우트는 돈을 아낀다. 비싼 프런티어 모델 대신 값싼 모델·로컬 모델(Ollama)로도 쓸 만한 코딩 에이전트를 굴리게 하는 것이 목표다 — 이름처럼 "열린(open)" 접근이다.

2왜 지금 주목받는가

TrendShift Daily #10 · #AI agent — "전설의 이름 + Codex 엔진 + 저비용 모델"이라는 세 겹의 화제성

Open Interpreter는 2023년 9월 GitHub 트렌딩 #1에 오르며 이름을 알린, 누적 66k 스타의 유서 깊은 프로젝트다. 그런 프로젝트가 파이썬을 버리고 OpenAI Codex를 포크해 완전히 새 몸으로 돌아왔다는 것 자체가 사건이다. 여기에 "저비용·로컬 모델도 잘 굴린다"는 실용적 매력과, README 상단의 "오늘, Kimi K3가 도착했다(Today: Kimi K3 is here)"는 신모델 대응 홍보가 겹쳐 다시 트렌딩에 올랐다.

포인트내용
정체OpenAI Codex의 하드포크 = 터미널 코딩 에이전트. 명령어 i/interpreter. TUI · 헤드리스(exec) · 에디터 내장(ACP)의 세 얼굴을 가진 단일 Rust 바이너리.
목표"저비용 모델에 최적화" — DeepSeek·Kimi·Qwen·GLM 같은 값싼 API와 Ollama·LM Studio 로컬 모델을 1급 시민으로 대우.
비밀 병기하니스 에뮬레이션 — 모델마다 그 모델이 훈련된 하니스(프롬프트+도구 포맷+와이어)를 흉내 내 씌워 성능을 극대화. 코드상 16종 하니스 정의.
혈통엔진은 검증된 Codex 것 그대로(세션·턴 루프·샌드박스·MCP·ACP). 그래서 처음부터 프로덕션급 — 신생 프로젝트의 미성숙함이 없다.
드롭인 호환Codex와 같은 실행 프로토콜을 말하므로, 기존 Codex SDK에서 codexPathOverride: "interpreter" 한 줄로 엔진만 갈아 끼울 수 있다.

주목 포인트 1 — "모델을 그 모델의 하니스로 감싼다"는 통찰

이 프로젝트가 던지는 가장 값진 메시지. 요즘 LLM은 순수한 "텍스트 예측기"가 아니라, 특정 에이전트 하니스 안에서 도구를 부르도록 강화학습(RL)으로 튜닝돼 있다. 그래서 Kimi 모델을 Claude Code식 프롬프트/도구 포맷에 넣으면 실력이 안 나온다 — 분포 밖(out-of-distribution)이기 때문이다. Open Interpreter는 이 문제를 정면으로 공략한다. 모델을 고르면 그 모델이 원래 뛰던 하니스를 자동으로 입혀 준다. "모델이 곧 에이전트"라는 최신 흐름을 제품으로 구현한 드문 사례다.

주목 포인트 2 — 지갑이 얇아도 되는 코딩 에이전트

Claude Code·Codex는 강력하지만 프런티어 모델 비용이 만만찮다. Open Interpreter는 DeepSeek·Kimi·Qwen·GLM 같은 저가 API, 그리고 Ollama·LM Studio로 돌리는 완전 로컬 모델을 기본 지원 대상으로 삼는다. 빌트인 프로바이더 목록(model-provider-info)에 openai·anthropic과 나란히 deepseek·kimi·moonshot·qwen·dashscope·openrouter·zai(GLM)·ollama·lmstudio가 박혀 있다. "좋은 코딩 에이전트를 값싸게, 혹은 내 컴퓨터 안에서"라는 수요를 정조준한다.

주목 포인트 3 — 검증된 엔진을 물려받은 이점

바닥부터 새로 짠 게 아니라 OpenAI가 다듬은 Codex 엔진을 물려받았다는 점은 큰 강점이다. 3-OS 네이티브 샌드박스(Landlock/Seatbelt/Windows), MCP·ACP 프로토콜 클라이언트, apply_patch 편집 엔진, 세션 리플레이, V8 기반 "code mode"까지 — 이 모든 성숙한 기반을 그대로 쓰면서, 자신은 "하니스"라는 차별화 레이어에만 집중한다. 신생 프로젝트가 흔히 겪는 안정성 문제를 건너뛴 영리한 전략이다.

중요 · 오해 방지 — "openinterpreter"라는 이름에 두 번 속지 말 것
① 파이썬 Open Interpreter가 아니다 ② 이름은 Open Interpreter인데 코드는 전부 "codex"다

속기 쉬운 점 ①: 예전 pip install open-interpreter로 쓰던 그 파이썬 프로젝트를 기대하고 오면 당황한다. 이건 완전히 다른 Rust 코드베이스이고, 파이썬 원조는 endolith/open-interpreter로 이관됐다.

속기 쉬운 점 ②: 소스를 열면 크레이트가 전부 codex-core·codex-tui처럼 "codex"로 시작한다. 디렉토리도 codex-rs/다. "왜 Open Interpreter인데 codex야?"에서 막히지 말자 — Codex를 하드포크했기 때문이다. "Open Interpreter"라는 정체성은 브랜딩 + 하니스 레이어일 뿐, 몸통은 Codex다. 심지어 서버 호환성 체크를 통과하려고 백엔드엔 Codex 호환 버전 0.144.5를 보고하고, 자기 제품 버전은 0.0.28로 따로 관리한다.

3기술 스택 전체 지도

주인공은 package.json이 아니라 codex-rs/Cargo.toml — 98개 크레이트가 얽힌 Rust 워크스페이스다

"코딩 CLI"라 하면 Node 프로젝트를 떠올리지만, Open Interpreter의 실체는 약 98개 크레이트로 이뤄진 Cargo 워크스페이스다(Rust .rs 파일 2,561개, 약 116만 줄). npm 런처(codex-cli)는 얇은 껍데기이고, 심지어 그 package.json은 아직 상류 Codex의 @openai/codex 메타데이터 그대로다. 스택을 이해하려면 "무엇이 화면을 그리고, 무엇이 모델과 말하고, 무엇이 안전을 지키는가"의 세 축으로 봐야 한다.

화면·터미널 (TUI 레이어)

요소내용
TUI 프레임워크ratatui 0.29.0 + 백엔드 crossterm 0.28.1(둘 다 nornagon 포크로 patch). Ink/React가 아니라 순수 Rust. codex-tui 크레이트가 담당.
터미널 렌더 보조ansi-to-tui 7.0.0, vt100 0.16.2(터미널 에뮬레이션), ratatui-macros 0.6.0.
퍼지 검색nucleo(Helix 편집기 출신 퍼지 매처) — 파일·명령 선택 UI에.

두뇌·통신 (모델·네트워크 레이어)

요소내용
LLM 클라이언트reqwest 0.12 + eventsource-stream 0.2.3(SSE 스트리밍). async-openai를 쓰지 않고 와이어를 직접 구현(chat-wire-compat·codex-backend-openapi-models) — 여러 API 규격을 자유롭게 다루기 위해서다.
와이어 규격WireApi enum 3종 — Responses(OpenAI /v1/responses), Chat(/v1/chat/completions 호환), Messages(Anthropic Messages API). 프로바이더마다 알맞은 규격 선택.
비동기 런타임tokio 1 + tokio-stream·tokio-util·async-channel·crossbeam-channel·futures 0.3.
MCPrmcp 1.7.0(공식 Rust MCP SDK) — 크레이트 codex-mcp·mcp-server·rmcp-client. MCP 클라이언트·서버 양쪽.
ACP(에디터 내장)agent-client-protocol 0.12.1 — Zed 등 편집기에 임베드하는 프로토콜. acp-server 크레이트.
로컬·클라우드로컬 ollama·lmstudio 크레이트 / 클라우드 aws-sigv4(Bedrock)·realtime-webrtc.

일·안전 (도구·샌드박스·상태 레이어)

요소내용
Git(VCS)gix 0.81.0(gitoxide) — libgit2가 아닌 순수 Rust Git. 체크포인트·워크트리에.
샌드박스·OSlandlock 0.4.4(Linux)·seccompiler 0.5.0(seccomp)·bwrap(bubblewrap), macOS Seatbelt, Windows 전용 샌드박스. 정책 언어는 Starlark 0.14.2(execpolicy).
상태·저장sqlx 0.9.0 + sqlite-bundled(rusqlite 아님). 세션 기록·리플레이(rollout·thread-store).
JS/V8 (code mode)v8 149.2.0 임베드 — 도구를 JS 함수처럼 노출해 모델이 코드를 짜서 도구를 호출하는 "code mode"(code-mode·code-mode-host).
파싱·보안tree-sitter 0.25.10 + tree-sitter-bash(bash 명령을 파싱해 정책 검사), bm25(키워드 검색), rustls 0.23, 포스트양자 clatter(Noise+ML-KEM), keyring 3.6.
CLI·직렬화clap 4(+completion), serde/serde_json/toml 0.9, 스키마 schemars, Rust→TS 타입 ts-rs 11.
핵심 용어 · 왜 와이어를 직접 짰나
WireApi · Responses / Chat / Messages
저비용 모델들은 저마다 API 방언이 다르다 — OpenAI식 /chat/completions, OpenAI의 신형 /responses, Anthropic의 /messages. Open Interpreter는 async-openai 같은 기성 SDK에 의존하지 않고 세 규격을 WireApi enum으로 직접 추상화했다. 왜? 하니스 에뮬레이션을 하려면 "어떤 모델 × 어떤 하니스 × 어떤 와이어 규격"의 조합을 자유롭게 라우팅해야 하는데, 남의 SDK에 갇히면 그게 안 된다. 예컨대 "Kimi 모델 + Kimi Code 하니스 + Chat 와이어" 같은 조합을 코드가 표로 관리한다(§4-2).
한눈에 — "세 개의 방으로 나뉜 공장"

스택이 복잡해 보여도 뼈대는 셋이다. 전시장(TUI)ratatui로 결과를 예쁘게 보여주고, 전화실(모델·네트워크)reqwest+SSE로 값싼 모델 서버(또는 로컬 Ollama)와 통화하며, 작업장(도구·샌드박스)gix·landlock·V8로 실제 코드를 만지되 안전선을 지킨다. 이 세 방이 tokio 비동기 컨베이어벨트로 연결돼 동시에 돈다. 이 공장 설계도는 사실 OpenAI가 그린 것(Codex)이고, Open Interpreter는 여기에 "손님 맞춤 유니폼 창고(하니스)"를 하나 더 지었다.

4아키텍처 심화 분석

에이전트 턴 루프 → 하니스 에뮬레이션 라우팅 → apply_patch 편집 → 3-OS 샌드박스, 이 넷이 핵심

4-1. 전체 구조도 — 사용자 한 줄에서 파일 수정까지

Open Interpreter를 이해하는 가장 빠른 길은 "당신이 친 한 문장"이 어떤 부품을 거쳐 "파일 수정"으로 끝나는지 따라가는 것이다. 핵심은 턴 루프(turn loop) — 모델에게 한 번 묻고, 도구를 실행하고, 결과를 다시 붙이는 한 사이클을, 작업이 끝날 때까지 반복하는 구조다. 그리고 그 입구에서 하니스가 선택돼, 모델에 맞는 프롬프트·도구·와이어가 결정된다.

┌──────────────────────────────────────────────────────────────────────┐ │ Open Interpreter 실행 흐름 (대화형 TUI 기준) │ │ │ │ [사용자 입력] "로그인 버그 고쳐줘" │ │ │ (codex-tui: ratatui TUI) │ │ v │ │ ┌──────────────────────────────────────────────┐ │ │ │ 하니스 선택 (harness/routing.rs) │ ← 여기가 차별점 │ │ │ 모델 = kimi-k2 → 하니스 = KimiCode │ │ │ │ → 시스템 프롬프트 + 도구 스키마 + 와이어 결정 │ │ │ └───────────────┬──────────────────────────────┘ │ │ v │ │ ┌──────────────────────────────────────────────┐ │ │ │ 세션/턴 (core: session/turn.rs, tasks/*) │ ← 턴 loop 지휘자 │ │ │ · 프롬프트 + 대화 이력 조립 │ │ │ │ · run_sampling_request 호출 │ │ │ └───────────────┬──────────────────────────────┘ │ │ │ (요청) SSE 스트림 │ │ v ◀─────────── │ │ ┌──────────────────────────────────────────────┐ 저비용 모델 서버 │ │ │ 모델 응답 스트림 (ResponseEvent::*) │ (또는 로컬 Ollama)│ │ │ OutputTextDelta · OutputItemDone(툴콜) · … │ │ │ └───────────────┬──────────────────────────────┘ │ │ │ (도구 호출 파싱) │ │ v │ │ ┌──────────────────────────────────────────────┐ │ │ │ 도구 실행 (core/src/tools/handlers/*) │ │ │ │ shell_command · apply_patch · update_plan … │ │ │ └───────────────┬──────────────────────────────┘ │ │ │ (단, 아래 벽 안에서만) │ │ v │ │ ┌──────────────────────────────────────────────┐ │ │ │ 샌드박스 (Landlock/Seatbelt/Windows) │ + execpolicy │ │ └───────────────┬──────────────────────────────┘ │ │ │ (도구 결과를 대화 이력에 되먹임) │ │ └────────► 세션으로 복귀 → 완료까지 루프 반복 │ └──────────────────────────────────────────────────────────────────────┘

턴 루프의 최상위 코드는 이렇게 생겼다(core/src/tasks/regular.rs). "대기 중인 입력이 없을 때까지" 턴을 반복하는 단순·견고한 구조다.

// core/src/tasks/regular.rs — 상위 태스크 루프 (요지)
let mut next_input = input;
loop {
    // run_turn: 모델 1회 호출 + 딸려 오는 도구 호출들을 처리
    let last_agent_message = run_turn(
        Arc::clone(&sess), Arc::clone(&ctx),
        Arc::clone(&turn_extension_data),
        next_input, prewarmed_client_session.take(),
        cancellation_token.child_token(),
    ).await?;

    if !sess.input_queue.has_pending_input(&sess.active_turn).await {
        return Ok(last_agent_message);   // 대기 입력 없으면 턴 종료
    }
    next_input = Vec::new();               // 큐에 쌓인 입력으로 다음 턴
}

run_turn 안에서는 run_sampling_request로 모델에 요청을 보낸 뒤, SSE로 흘러오는 ResponseEvent들을 종류별로 처리한다 — OutputTextDelta(스트리밍 텍스트), OutputItemDone(완성된 도구 호출/메시지), ReasoningSummaryDelta(추론 요약), Completed(턴 종료) 등. 전형적인 "서버 이벤트 스트림 소비" 패턴이다.

4-2. 하니스 에뮬레이션 — 이 프로젝트의 심장

여기가 Open Interpreter를 그냥 "또 하나의 Codex"가 아니게 만드는 지점이다. core/src/harness/ 아래에는 하니스마다 세 가지가 한 세트로 묶여 있다: ① 튜닝된 시스템 프롬프트(.md), ② 도구 스키마(.json), ③ 포맷/파싱 Rust 코드. 예컨대 kimi_code.rs + kimi_code_system_prompt.md + kimi_code_tools.json.

하니스 에뮬레이션 = (모델) 에 (그 모델의 하니스) 를 입힌다 core/src/harness/ ├── kimi_code.rs ┐ ├── kimi_code_system_prompt.md │ "You are Kimi Code CLI…" ├── kimi_code_tools.json ┘ (Kimi가 훈련받은 도구 포맷) ├── claude_code.rs ┐ ├── claude_code_system_prompt.md │ "You are an interactive agent…" ├── claude_code_tools.json┘ └── routing.rs ← (와이어 × 하니스) → 전송 경로 매트릭스 routing.rs :: resolve_stream_transport_route ┌────────────────────────┬────────────────────────────┐ │ (Responses, ClaudeCode)│ → Anthropic 경유 route │ │ (Chat, KimiCode) │ → Kimi route │ │ (Messages, ZCode) │ → Anthropic Messages route │ │ … │ … │ └────────────────────────┴────────────────────────────┘

프롬프트는 실제로 대상 하니스를 사칭한다. Kimi 하니스 프롬프트의 첫 줄은 "You are Kimi Code CLI…", Claude Code 하니스는 "You are an interactive agent that helps users with software engineering tasks…"로 시작한다. 저비용 모델이 "내가 원래 뛰던 그 환경이구나" 하고 착각하게 만들어, RL로 학습한 실력을 그대로 발휘하게 하는 것이다. 코드에는 README가 소개하는 것보다 많은 16종 하니스가 정의돼 있다(tools/src/harness.rs): Native · ClaudeCode · ClaudeCodeBare · DeepSeekTui · KimiCode · KimiCli · ZCode · LittleCoder · MiniSweAgent · OpenCode · Pi · QwenCode · SweAgent · Terminus2 · Minimal · Other. 런타임에 /harness 명령으로 갈아 끼운다.

핵심 통찰 · 왜 이게 중요한가
"모델이 곧 에이전트" · 분포 정합(distribution match)
과거엔 프롬프트 엔지니어링으로 아무 모델이나 아무 하니스에 끼워 썼다. 하지만 에이전트 능력을 RL로 직접 학습한 요즘 모델은, 훈련 때 본 하니스와 최대한 똑같은 환경에서만 최고 성능이 난다. Open Interpreter의 하니스 에뮬레이션은 이 "분포 정합"을 자동화한 것이다. 값싼 모델일수록 하니스 이탈에 취약하니, 저비용 모델을 노리는 이 프로젝트에겐 하니스 정합이 곧 생존 전략이다. 여기서 배울 교훈: 이제 에이전트 성능은 프롬프트 문구보다 "모델이 훈련된 하니스를 얼마나 정확히 재현하느냐"에 달렸다.

4-3. apply_patch — Codex 시그니처 편집 포맷

파일 수정 도구 apply_patch는 Codex 혈통을 가장 잘 보여준다. "이 문자열을 저 문자열로"(exact match)가 아니라, V4A라는 자유형(freeform) 패치 포맷을 쓴다 — *** Begin Patch로 시작해 *** Update File:로 대상을 지정하고, @@ 컨텍스트 앵커 아래에 +(추가)·-(삭제)· (문맥) 줄을 나열한다. 이 포맷은 Lark 문법(apply_patch.lark)으로 파싱된다.

# apply_patch 도구가 받는 V4A 패치 포맷 예시
*** Begin Patch
*** Update File: src/login.rs
@@ fn verify_token(token: &str)
-    if token.is_empty() {
+    if token.trim().is_empty() {
         return Err(AuthError::Empty);
     }
*** End Patch

컨텍스트 줄(@@ 앵커와 주변 문맥)로 위치를 잡기 때문에, 파일이 조금 바뀌어도 정확한 라인 번호 없이 수정 지점을 찾아낸다. 셸 도구 shell_command의 스키마도 살펴보면 Codex의 설계 철학이 보인다 — workdir를 반드시 넘기게 하고 cd 사용을 지양하도록 설명에 못 박아, 에이전트가 작업 디렉토리를 잃지 않게 한다.

// core/src/tools/handlers/shell_spec.rs (요지)
ToolSpec::Function(ResponsesApiTool {
    name: "shell_command".to_string(),
    description: r#"Runs a shell command and returns its output.
- Always set the `workdir` param ...
- Do not use `cd` unless absolutely necessary."#.to_string(),
    strict: false,
    // command(필수) · workdir · timeout_ms(기본 10000) · login …
})

4-4. 3-OS 네이티브 샌드박스 + Starlark 정책

에이전트가 내 컴퓨터에서 셸을 돌리는 건 무섭다. Codex 엔진은 세 운영체제 각각에 네이티브 샌드박스를 구현해 뒀고, Open Interpreter는 이를 그대로 물려받는다.

샌드박스 계층 (Codex 엔진 상속) ┌──────────────────────────────────────────────────────────────┐ │ Linux → Landlock(파일 접근 제한) + seccomp(시스템콜 필터) │ │ + bubblewrap(bwrap: 네임스페이스 격리) │ │ macOS → Seatbelt (sandbox-exec 프로필) │ │ Windows → AppContainer · ACL · ConPTY · 데스크톱 격리 │ │ │ │ 명령 허용/차단 판정 → execpolicy (Starlark 정책 언어) │ │ bash 명령을 tree-sitter-bash 로 파싱해 검사 │ └──────────────────────────────────────────────────────────────┘

가장 배울 만한 부분은 execpolicy다. "어떤 명령을 자동 허용하고 무엇을 막을지"를 Starlark(파이썬 비슷한 설정 언어)로 규칙을 기술하고, 실제 bash 명령은 tree-sitter-bash구문 트리를 파싱해 검사한다. 문자열 매칭이 아니라 파서 기반이라, rm -rf /를 교묘히 감싼 명령도 잡아낼 여지가 크다. "자동화 도구에 최소 권한을 어떻게 강제하는가"의 교과서적 사례다.

한눈 정리 · 아키텍처가 지키는 핵심 4가지
턴 루프 · 하니스 에뮬레이션 · 컨텍스트 기반 편집 · 커널 샌드박스

턴 루프: "대기 입력 없을 때까지" 모델↔도구를 반복하는 단순·견고한 자율 실행. ② 하니스 에뮬레이션: (와이어 × 하니스) 매트릭스로 모델마다 최적 껍데기를 씌우는 이 프로젝트만의 레이어. ③ apply_patch(V4A): 라인 번호가 아닌 컨텍스트 앵커로 수정 지점을 찾는 견고한 편집. ④ 커널 샌드박스: 최소 권한을 앱 로직이 아닌 OS 커널 + Starlark 정책으로 강제. ①③④는 Codex에게 물려받은 튼튼한 뼈대, ②는 Open Interpreter가 얹은 차별점이다.

5디렉토리 · 크레이트 구조 해부

98개 크레이트 / 약 116만 줄 Rust — 몸통은 codex-rs/, 그 안의 core/가 엔진

저장소는 거대하지만 규칙적이다. 루트 최상위는 크게 Rust 본체(codex-rs/) · npm 런처(codex-cli/) · TypeScript SDK(sdk/) · 문서(docs/)로 나뉜다. "무엇을 먼저 읽어야 하는가" 관점의 지도는 아래와 같다.

openinterpreter/ ├── README.md ★ "fork of OpenAI's Codex" 명시 + Kimi K3 공지 ├── CHANGELOG.md 한 줄 — openai/codex releases 로 위임(포크 증거) ├── LICENSE (Apache-2.0) · NOTICE (OpenAI Codex 저작권 보존) ├── codex-rs/ ★★ Rust 워크스페이스 = 본체 (98 크레이트) │ ├── Cargo.toml 워크스페이스 루트 (version 0.0.28, edition 2024) │ ├── rust-toolchain.toml Rust 1.95.0 고정 │ ├── core/ ★ 에이전트 엔진 (session·turn·tools·harness·sandbox) │ │ ├── src/tasks/regular.rs 상위 턴 루프 │ │ ├── src/session/turn.rs run_turn (모델 1회 + 도구들) │ │ ├── src/harness/ ★ 하니스 에뮬레이션 (프롬프트+툴+라우팅) │ │ └── src/tools/handlers/ 도구 구현 (shell·apply_patch·plan…) │ ├── tui/ cli/ exec/ exec-server/ TUI · 진입점 · 헤드리스 │ ├── tools/ protocol/ config/ prompts/ │ ├── acp-server/ app-server/ 에디터·IDE JSON-RPC 서버 │ ├── codex-mcp/ mcp-server/ rmcp-client/ ext/(mcp·skills·web-search·memories) │ ├── execpolicy/ linux-sandbox/ windows-sandbox-rs/ bwrap/ sandboxing/ │ ├── model-provider(-info)/ models-manager/ ollama/ lmstudio/ │ ├── rollout/ thread-store/ skills/ hooks/ 세션 기록·스킬·훅 │ ├── code-mode(-host)/ v8-poc/ V8 임베드 "code mode" │ └── product-info/ ★ enum Product { Codex, OpenInterpreter } ├── codex-cli/ npm 런처(bin/codex.js — 아직 @openai/codex 메타) ├── sdk/ TypeScript SDK (636 .ts) ├── docs/ docs-site/ install.md · kimi-k3.md · contributing.md … └── .codex/skills/ 레포 자체 개발용 스킬(code-review · babysit-pr …)

꼭 먼저 볼 크레이트

크레이트/경로역할
codex-rs/core엔진의 심장. 세션·턴 루프·도구 실행·하니스·샌드박싱을 모두 담는다. 여길 읽으면 에이전트가 어떻게 도는지 다 보인다.
core/src/harness이 프로젝트만의 차별점. 하니스별 시스템 프롬프트(.md)+도구 스키마(.json)+포맷 Rust. routing.rs가 (와이어×하니스)→경로 매트릭스.
core/src/tools/handlers도구 구현. *_spec.rs가 스키마, 나머지가 핸들러. shell_command·apply_patch·update_plan·multi_agents 등.
product-infoenum Product { Codex, OpenInterpreter } — 같은 바이너리가 두 브랜드로 동작하게 하는 스위치(§6).
model-provider-info빌트인 프로바이더/모델 카탈로그. WireApi enum, provider_catalog.json(스크립트로 생성).
tui / exec / acp-server같은 core세 얼굴로 노출 — 대화형 TUI · 헤드리스 실행 · 에디터(ACP) 서버.
한눈에 — "codex 간판을 단 크레이트들에 겁먹지 말 것"

크레이트가 98개에 이름은 죄다 codex-*라 압도되기 쉽다. 하지만 규칙만 알면 조직도처럼 읽힌다. codex-core엔진(공장 전체), codex-tui/codex-exec출입구(사용 방식), *-sandbox/execpolicy보안팀, ext/*가 확장(웹검색·메모리·스킬)이다. "codex"는 성(姓)이고, 실제 우리가 눈여겨볼 새 식구는 harness/product-info/ 둘뿐이라고 생각하면 편하다.

6학습 포인트

"Open Interpreter 사용법"이 아니라 "저비용 모델을 실전에 태우는 에이전트 설계"로 가져갈 것들

배울 것 1 — 하니스 에뮬레이션이라는 새 패러다임

가장 값진 교훈. 모델마다 그 모델이 훈련된 하니스로 감싸야 성능이 난다는 통찰을, (와이어 × 하니스) 라우팅 매트릭스로 실제 구현한 코드를 볼 수 있다. "프롬프트를 잘 쓰면 아무 모델이나 된다"는 낡은 감각을, "모델·하니스·와이어의 분포를 정합시켜라"로 업데이트하는 실물 교보재다. 저비용/오픈 모델을 제품에 태우려는 사람이라면 반드시 봐야 할 접근.

배울 것 2 — 하나의 바이너리, 두 개의 브랜드

product-info/src/lib.rsenum Product { Codex, OpenInterpreter }. 같은 실행 파일이 argv0(interpreter/i) · 환경변수 OPEN_INTERPRETER_BRAND · 패키지 메타데이터로 자기 정체를 결정한다. 심지어 서버 호환성 체크를 통과하려고 백엔드엔 Codex 호환 버전(0.144.5)을 보고하되 제품 버전은 0.0.28로 따로 관리한다. "포크 제품이 상류와 호환성을 유지하면서 독자 정체성을 갖는 법"의 실전 사례.

배울 것 3 — 컨텍스트 기반 편집(apply_patch / V4A)

정확한 라인 번호나 문자열 완전 일치 대신 @@ 컨텍스트 앵커로 수정 지점을 찾는 V4A 포맷, 그리고 그것을 Lark 문법으로 파싱하는 방식. "LLM이 생성한 편집을 어떻게 견고하게 적용하는가"라는, 코딩 에이전트의 핵심 난제를 다루는 법을 배운다.

배울 것 4 — 파서 기반 명령 정책(execpolicy)

위험한 셸 명령을 문자열 블랙리스트가 아니라 tree-sitter-bash 구문 트리 + Starlark 정책으로 판정하는 설계. 정규식 우회에 취약한 문자열 검사의 한계를 파서로 넘어서는 실전 보안 코드다. 자동화·CI 도구를 만들 누구에게나 값진 사고 훈련.

배울 것 5 — 도구를 코드로 부르는 "code mode"(V8 임베드)

Rust 안에 V8 자바스크립트 엔진(v8 149.2.0)을 임베드해, 도구들을 JS 함수처럼 노출하고 모델이 코드를 짜서 도구를 조합 호출하게 하는 실험적 경로(code-mode). "도구 호출을 하나씩 JSON으로"에서 "여러 도구를 코드 한 조각으로 오케스트레이션"으로 넘어가는 최신 아이디어를 소스로 확인할 수 있다.

배울 것 6 — 초대형 Cargo 워크스페이스 운영

98개 크레이트, rust-toolchain.toml로 못 박은 툴체인(1.95.0), Cargo와 Bazel(MODULE.bazel)의 병존, 프로바이더 카탈로그를 scripts/write_provider_catalog.py로 생성해 Rust에 임베드하는 코드젠 패턴. "Rust 모노레포를 재현 가능하고 일관되게 유지하는 법"의 모범 사례다.

한 줄 정리 · 재사용 가능한 교훈
"이 저장소의 진짜 교재 가치는 'Open Interpreter 쓰는 법'이 아니라 '저비용 모델을 제품 수준 에이전트로 태우는 아키텍처'다"

모델이 Kimi든 DeepSeek든, 이 저장소가 남기는 원칙은 보편적이다. 모델을 그 모델의 하니스로 감싸고(분포 정합), 편집은 컨텍스트 앵커로 견고하게, 위험 명령은 파서로 걸러라. 여기에 "검증된 상류(Codex)를 포크해 차별화 레이어에만 집중"이라는 제품 전략까지. 코딩 에이전트를 직접 만들 생각이 없어도, 오픈·저가 모델을 실전에 올리려는 설계자라면 뜯어볼 값어치가 크다.

7시스템 · 실행 요구사항

두 갈래 — "그냥 쓰기(설치 스크립트)"와 "소스에서 직접 빌드(Rust 툴체인)"

대부분의 사용자는 설치 스크립트 한 줄이면 된다. 반면 소스에서 빌드하려면 Rust 툴체인이 필요하다. 아래 표가 두 경로를 가른다.

항목요구/수치
설치(권장)macOS/Linux: curl -fsSL https://www.openinterpreter.com/install | sh · Windows: irm https://www.openinterpreter.com/install.ps1 | iex. 실행은 i 또는 interpreter.
모델·인증저비용 API 키(DeepSeek/Kimi/Qwen/GLM/OpenRouter 등) 또는 로컬 서버(Ollama·LM Studio). OpenAI/Anthropic도 지원. 프로바이더별 키·엔드포인트 설정.
OS·샌드박스macOS · Linux · Windows 3종 모두 네이티브 샌드박싱 지원(Seatbelt / Landlock+seccomp+bwrap / AppContainer).
GPU불필요. 추론은 외부 API 또는 로컬 추론 서버(Ollama 등)에 위임 — 이 프로그램 자체는 순수 클라이언트. (로컬 모델을 직접 돌린다면 그 서버의 요구사항은 별개.)
빌드(소스)Rust 툴체인 1.95.0 고정(codex-rs/rust-toolchain.toml, edition 2024). Cargo 또는 Bazel. 실행: cargo run(codex-rs 워크스페이스).
npm 런처(선택)codex-cliengines.node >= 16. 단 Open Interpreter는 curl 설치를 권장하므로 일반 사용자에겐 Node 불요.
한눈 요약 — "완제품을 살까, 부품으로 조립할까"

설치 스크립트는 "완제품 구매"다 — 내려받아 저비용 모델 키만 넣으면 끝, Rust를 몰라도 된다. 반면 소스 빌드는 "부품 조립 키트"라 Rust 1.95.0 툴체인이 필요하다. 대다수는 완제품으로 충분하고, "하니스 에뮬레이션이 진짜 어떻게 도는지 뜯어보고 싶은 사람"만 조립 경로로 간다. GPU가 없어도 되니, 값싼 API 키 하나로 누구나 시작할 수 있다는 게 이 프로젝트의 매력이다.

8직접 해볼 수 있는 실습 과제

난이도별 — "설치·체험 → 저비용/로컬 모델 연결 → 하니스 전환 → 소스 읽기 → 하니스 프롬프트 비교"

먼저 설치. 스크립트 한 줄이면 된다.

# 설치 (macOS/Linux)
curl -fsSL https://www.openinterpreter.com/install | sh

i               # 대화형 TUI 실행 (또는 interpreter)
실습 1 · 난이도 ★☆☆☆☆

TUI로 작은 수정 한 번 시켜 보기 — 에이전트 루프 체감

아무 작은 저장소에서 i를 띄우고 "이 함수에 주석 달아줘" 정도를 시켜 본다. 에이전트가 셸을 돌리고(shell_command) → 파일을 고치고(apply_patch) → diff를 보여주는 흐름을 §4-1 구조도와 대조하며 눈으로 확인한다.

실습 2 · 난이도 ★★☆☆☆

저비용/로컬 모델로 갈아 끼우기 — Ollama · DeepSeek

이 프로젝트의 존재 이유를 체험하는 실습. 로컬 ollama 모델이나 값싼 DeepSeek API 키로 프로바이더를 바꿔 같은 작업을 시켜 본다. 프런티어 모델 대비 비용·속도·품질이 어떻게 달라지는지 감을 잡는다. "코딩 에이전트를 지갑 걱정 없이 굴린다"가 무슨 뜻인지 몸으로 안다.

실습 3 · 난이도 ★★★☆☆

하니스를 바꿔 성능 차이 관찰 — /harness

같은 저비용 모델을 두고 /harness여러 하니스(예: Native ↔ KimiCode ↔ ClaudeCode)를 갈아 끼우며 같은 작업을 반복시켜 본다. 하니스에 따라 도구 호출 성공률·품질이 눈에 띄게 달라지는지 관찰하면, "분포 정합"의 실체를 직접 체감할 수 있다.

실습 4 · 난이도 ★★★★☆

소스 클론해 턴 루프 읽기 — Rust 안 써도 구조는 읽힌다

git clone --depth 1로 받아 codex-rs/core/src/tasks/regular.rssession/turn.rs를 연다. "모델 호출 → ResponseEvent 처리 → 도구 실행 → 되먹임"의 흐름을 따라가고, core/src/tools/handlers/에서 어떤 도구가 등록되는지 확인한다.

실습 5 · 난이도 ★★★★★

하니스 프롬프트 3종을 비교 분석 — harness/*.md

codex-rs/core/src/harness/kimi_code_system_prompt.md·claude_code_system_prompt.md 등을 열어, 각 하니스가 모델에게 자기 정체를 어떻게 사칭시키는지, 도구 스키마(.json)가 어떻게 다른지 비교한다. routing.rs의 (와이어×하니스) 매트릭스까지 읽어, "왜 이 모델엔 이 하니스인가"의 규칙을 스스로 정리해 본다.

9관련 기술 심화 학습 로드맵

Open Interpreter를 정복하며 곁들여 익히면 좋은 것들 — 주차별 5단계
주차주제 · 목표
1주차에이전트 루프의 기본기. "생각→도구 호출→관찰→반복"의 ReAct식 루프, 도구 스키마(JSON Schema), SSE 스트리밍 응답 소비. 목표: §4-1 구조도를 스스로 그릴 수 있게.
2주차하니스·프롬프트 엔지니어링. "모델이 곧 에이전트" 개념, RL로 학습된 도구 사용, 분포 정합(distribution match)이 왜 성능을 좌우하는지. harness/를 읽을 수 있게.
3주차Rust 비동기. tokio 태스크·채널, reqwest+eventsource-stream으로 SSE를 소비하는 법. 스트리밍 에이전트의 뼈대를 이해.
4주차OS 샌드박스·보안. Linux Landlock·seccomp·bubblewrap, macOS Seatbelt, 그리고 tree-sitter로 명령을 파싱해 정책 검사하는 법. "최소 권한을 커널로 강제".
5주차에이전트 상호운용 프로토콜. MCP(도구 연결)·ACP(에디터 연결)·OpenAI Responses API를 클라이언트로 구현·소비. "내 에이전트를 남의 생태계에 끼우기".

10핵심 키워드 사전

이 문서와 저장소에서 반복되는 용어 빠른 참조
용어
Open Interpreter여기서는 Rust로 재작성된 새 프로젝트 = OpenAI Codex의 하드포크. 저비용 모델용 코딩 에이전트. 명령어 i/interpreter. (파이썬 원조는 endolith/open-interpreter로 이관.)
CodexOpenAI의 터미널 코딩 에이전트(codex-rs). 이 저장소의 몸통·엔진. 크레이트 이름이 전부 codex-*인 이유.
하니스 (harness)LLM을 감싸는 껍데기 = 시스템 프롬프트 + 도구 포맷 + API 와이어 규격의 한 세트. 모델은 특정 하니스에 맞춰 RL로 튜닝돼 있다.
하니스 에뮬레이션모델을 그 모델이 훈련받은 하니스로 흉내 내 감싸 성능을 극대화하는 이 프로젝트의 핵심 기법. 코드상 16종 하니스.
분포 정합모델이 훈련 때 본 환경과 실행 환경을 최대한 일치시키는 것. 하니스 에뮬레이션의 목적. 저비용 모델일수록 이탈에 취약.
턴 루프 (turn loop)모델 1회 호출 → 도구 실행 → 결과 되먹임의 한 사이클. "대기 입력 없을 때까지" 반복. 코드상 tasks/regular.rs·session/turn.rs.
WireApiAPI 와이어 규격 enum 3종 — Responses(OpenAI /responses)·Chat(/chat/completions)·Messages(Anthropic).
apply_patch · V4ACodex식 파일 편집 도구/포맷. 라인 번호가 아닌 @@ 컨텍스트 앵커로 수정 지점을 찾음. Lark 문법으로 파싱.
execpolicyStarlark 언어로 명령 허용/차단 규칙을 기술하고, bash는 tree-sitter-bash로 파싱해 검사하는 정책 엔진.
code modeV8(v8 149.2.0)을 임베드해 도구를 JS 함수로 노출, 모델이 코드를 짜서 도구를 조합 호출하는 실험적 방식.
MCP · ACP각각 도구 연결(Model Context Protocol, rmcp) · 에디터 내장(Agent Client Protocol, Zed식). 둘 다 지원.
enum Product같은 바이너리를 Codex/OpenInterpreter 두 브랜드로 동작시키는 스위치. 백엔드엔 Codex 호환버전(0.144.5) 보고.

11참고 링크

공식 소스 우선 — 버전·수치는 클론한 소스(제품 0.0.28, 커밋 e79e546) 기준

공식
· GitHub 저장소: github.com/openinterpreter/openinterpreter (Apache-2.0 · OpenAI Codex 하드포크)
· TrendShift 카드: trendshift.io/repositories/8740 (Daily #10 · #AI agent)
· 홈페이지·설치: openinterpreter.comcurl -fsSL https://www.openinterpreter.com/install | sh
· 파이썬 원조(별개 프로젝트): github.com/endolith/open-interpreter

저장소 안에서 꼭 읽을 것
· codex-rs/core/src/harness/ — 하니스 에뮬레이션(이 프로젝트의 심장)
· codex-rs/core/src/tasks/regular.rs · session/turn.rs — 턴 루프
· codex-rs/core/src/tools/handlers/ — 도구 구현(shell·apply_patch·plan)
· codex-rs/product-info/src/lib.rs — 듀얼 브랜드 스위치
· codex-rs/model-provider-info/ — WireApi + 프로바이더 카탈로그
· README.md · NOTICE — 포크 혈통과 저작권 고지

곁들여 학습
· ratatui · crossterm — Rust TUI 프레임워크
· tokio · reqwest · eventsource-stream — 비동기 · SSE 스트리밍
· Linux Landlock · seccomp · bubblewrap / macOS Seatbelt — OS 샌드박스
· OpenAI Responses API · MCP(Model Context Protocol) · ACP(Agent Client Protocol)
· 이미 분석한 다른 터미널 코딩 에이전트 딥다이브와 비교(§인덱스 cat-coding-cli — grok-build 등)

참고 · 소스 정독으로 확인한 주의점
"이름은 Open Interpreter, 속은 Codex"라는 성격을 잊지 말 것

① 이건 파이썬 Open Interpreter가 아니다 — 완전히 다른 Rust 코드베이스이고, 파이썬 원조는 endolith/open-interpreter로 이관됐다. ② 코드가 전부 codex-*인 이유는 OpenAI Codex의 하드포크이기 때문. NOTICE에 OpenAI 저작권이 보존돼 있다. ③ 버전이 이원화 — 제품 버전 0.0.28이지만 서버 호환용으로 Codex 버전 0.144.5를 보고한다. ④ npm 메타데이터(@openai/codex)는 상류 그대로라, 설치는 npm이 아니라 curl 스크립트를 써야 한다. ⑤ README의 "Kimi K3"와 카탈로그의 GLM-5·Kimi-K2.6·DeepSeek-V3.2공격적·미래형 모델명은 실존 여부 검증 필요(문서 시점 기준 미확인). ⑥ 한국어 README는 없다(EN·ES·ZH 3종만) — 사실상 첫 한국어 정리. ⑦ 상류 openai/codex를 추종하는 하드포크라, 이 미러의 상당 부분은 저비용 용도와 무관한 Codex 상류 인프라다. ⑧ 이 문서 수치는 분석 시점 최신 커밋(2026-07-17, e79e546) 기준이며, 트렌딩 특성상 순위·지표는 계속 바뀐다.