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

xai-org/grok-build 딥다이브
— xAI가 직접 만든 터미널 코딩 에이전트, 그 Rust 내부를 뜯다

grok-build(명령어 grok)은 xAI(=SpaceXAI)가 공식으로 내놓은 터미널 기반 AI 코딩 에이전트다. 전체 화면 TUI로 떠서 당신의 코드베이스를 이해하고, 파일을 고치고, 셸 명령을 돌리고, 웹을 뒤지고, 오래 걸리는 작업을 백그라운드로 굴린다. Claude Code·Codex·Gemini CLI가 차지한 "터미널 코딩 에이전트" 전쟁에 xAI가 Grok 모델을 등에 업고 뛰어든 정면 승부수다. 놀라운 건 언어다. TypeScript가 대세인 이 바닥에서 grok-build는 전부 Rust로 짜였다 — 2,172개의 .rs 파일, 약 133만 줄, 85개 크레이트(crate)의 초대형 워크스페이스. TUI는 ratatui, 모델 연결은 OpenAI 호환 Responses API, 그리고 codex·opencode의 편집 도구를 소스째 이식해 여러 도구 설계를 A/B 실험하는 흔적까지 그대로 드러난다. 이 문서는 공개 미러를 소스까지 클론해 "여기서 무엇을 배울 수 있는가"를 정리한다. (저장소: xai-org/grok-build · 내부 모노레포에서 동기화되는 공개 미러 · Rust edition 2024 · Apache-2.0 © 2023-2026 SpaceXAI · npm v0.1.220-alpha.4 · 최신 커밋 2026-07-16 · TrendShift Daily #1 · #AI agent #AI coding assistant)
목차
  1. 프로젝트 한 줄 요약
  2. 왜 지금 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 · 크레이트 구조 해부
  6. 학습 포인트
  7. 시스템 · 실행 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한 줄 요약

이름부터 뜯어보기 — "grok"(깊이 이해하다) + "build"(짓다) = 당신을 대신해 코드를 이해하고 짓는 터미널 조수

grok-build"xAI가 만든, 터미널 안에서 사는 코딩 에이전트"다. VS Code 같은 GUI 편집기가 아니라, 검은 터미널 창을 꽉 채우는 TUI(텍스트 사용자 인터페이스)로 뜬다. 당신이 "로그인 버그 고쳐줘"라고 자연어로 치면, 에이전트가 스스로 파일을 읽고(ReadFileTool), 코드를 뒤지고(GrepTool), 셸을 돌리고(BashTool), 코드를 고쳐(SearchReplaceTool) 결과를 화면에 실시간으로 흘려준다. 이 "생각→도구 호출→관찰→다시 생각"의 반복(에이전트 루프)이 grok-build의 심장이다.

세 가지 방식으로 쓸 수 있다는 점이 특징이다. ① 대화형(TUI)은 사람이 직접 마주 앉아 쓰는 전체 화면 모드, ② 헤드리스(grok agent ...)는 CI/CD 파이프라인이나 스크립트가 사람 없이 부르는 모드, ③ 에디터 내장ACP(Agent Client Protocol)로 Zed 같은 편집기 안에 박혀 도는 모드다. 하나의 Rust 바이너리가 상황에 따라 세 얼굴을 갖는 셈이다.

핵심 용어
TUI (Terminal User Interface) · ratatui
TUI는 마우스·창이 있는 GUI와 달리, 터미널(검은 명령창) 안에 글자로 그려지는 화면이다. 그런데 grok-build의 TUI는 옛날 도스 화면처럼 투박하지 않다 — 전체 화면을 잡고, 마우스로 스크롤·클릭이 되고, 코드 문법 색칠·이미지·PDF·다이어그램까지 터미널 안에 그려준다. 이 화면을 그리는 뼈대가 Rust의 ratatui(0.29)라는 라이브러리다. Claude Code나 Codex CLI가 자바스크립트의 Ink(React 기반)로 TUI를 그리는 것과 달리, grok-build는 순수 Rust ratatui로 그린다. 이 언어 선택 하나가 프로젝트 전체 성격을 규정한다(§3).
핵심 용어
공개 미러 (read-only mirror) · SOURCE_REV
이 저장소는 xAI 내부의 거대한 모노레포(monorepo)에서 주기적으로 복사해 온 "읽기 전용 거울"이다. 루트의 SOURCE_REV 파일에 원본 모노레포의 커밋 해시가 박혀 있고, 모든 공개 커밋 메시지는 똑같이 "Synced from monorepo"다. 그래서 외부 기여(PR)를 받지 않는다(CONTRIBUTING.md에 명시). 공개 이유는 "소스 투명성과 로컬 빌드"를 위해서다 — 즉 코드를 열어 보여주고 직접 빌드하게는 하되, 개발 자체는 내부에서 한다. 커밋 히스토리가 단 하나로 뭉개져 있어 "언제 무엇이 바뀌었나"는 이 미러로 추적 불가.
한 문장 비유

"터미널 안에 들어앉은 시니어 페어 프로그래머 — 당신이 말로 시키면, 스스로 파일을 열고 명령을 돌려 일을 끝낸다"

grok-build는 옆자리에 앉아 키보드를 나눠 쓰는 숙련 동료 같다. "이 테스트 왜 깨지는지 봐줘"라고 하면, 그는 로그를 읽고(도구), 관련 파일을 뒤지고(도구), 고쳐 보고(도구), 다시 테스트를 돌려(도구) 확인한 뒤 요약해 준다. 다른 점은 그 동료가 xAI의 Grok 모델이고, 손발은 Rust로 짠 도구 모음이라는 것뿐이다.

게다가 이 동료는 위험한 일을 함부로 하지 않도록 모래상자(sandbox)에 갇혀 있고, 헛돌기 시작하면(같은 말 반복=doom-loop) 스스로 멈춘다. "똑똑한 자동화"와 "안전장치"를 한 바이너리에 욱여넣은 것이 이 프로젝트의 야심이다(§4).

2왜 지금 주목받는가

TrendShift Daily #1 · #AI agent — "Claude Code·Codex의 아성에 xAI가 Grok을 들고 정면 도전"

2026년 터미널 코딩 에이전트 시장은 이미 붐빈다 — Anthropic의 Claude Code, OpenAI의 Codex CLI, Google의 Gemini CLI가 각축 중이다. grok-build가 하루 만에 TrendShift Daily #1(모멘텀 9.5k)에 오른 이유는 단순하다. 이 대열에 xAI가 자사 Grok 모델을 무기로 공식 참전했고, 그것도 소스를 통째로 공개했기 때문이다. "빅3 랩이 각자 자기 모델용 코딩 CLI를 낸다"는 흐름이 이제 xAI까지 완성된 것이다.

포인트내용
정체xAI 공식 터미널 코딩 에이전트. 명령어 grok. 단일 Rust 바이너리(xai-grok-pager)가 대화형 TUI · 헤드리스 · 에디터 내장의 세 모드로 동작.
언어대세인 TypeScript가 아니라 전부 Rust(edition 2024, 133만 줄, 85개 크레이트). TUI는 ratatui, Git은 순수 Rust gix, 샌드박스는 nono.
모델기본 모델 grok-build컨텍스트 50만 토큰, CLI 전용(공개 API 미노출). 웹검색은 grok-4.20-multi-agent. grok-4.5·grok-code-fast-1 등도 지정 가능.
개방성Apache-2.0로 소스 공개. 단 내부 모노레포의 읽기 전용 미러라 PR은 안 받음("소스 투명성 + 로컬 빌드"용).
호환 야심스킬을 .claude/skills/·.cursor/skills/에서도 읽고, AGENTS.md 규칙을 따르며, codex·opencode의 편집 도구를 이식 — 경쟁 생태계와의 상호운용을 대놓고 챙김.

주목 포인트 1 — "왜 Rust인가"라는 무거운 베팅

Claude Code·Codex CLI·Gemini CLI는 모두 Node/TypeScript 기반이다. grok-build만 홀로 Rust로 처음부터 다시 짰다. 이건 취향이 아니라 전략적 베팅이다. Rust를 택하면 (1) 단일 정적 바이너리로 배포돼 Node 런타임·node_modules가 필요 없고, (2) 시동이 빠르고 메모리가 예측 가능하며(jemalloc 힙 프로파일링까지 내장), (3) OS 수준 샌드박스(Landlock/Seatbelt)·seccomp를 직접 붙이기 좋고, (4) ratatui로 그린 TUI가 무겁지 않다. 대가는 개발 난이도 — 그런데 xAI는 그 대가를 치르고 85개 크레이트짜리 거대 워크스페이스를 감수했다.

주목 포인트 2 — 경쟁 도구를 "소스째" 품고 A/B 실험한다

가장 흥미로운 대목. grok-build의 도구 구현 폴더(xai-grok-tools/src/implementations/)에는 여러 벌의 "편집 도구 세트"가 나란히 들어 있다 — 자체 grok_build 세트뿐 아니라, OpenAI codexapply_patch 방식 이식본, sst/opencode의 도구 이식본, 그리고 실험적인 grok_build_hashline·grok_build_concise까지. Apache 라이선스 §4(b)에 따른 변경 고지(THIRD_PARTY_NOTICES.md)도 정직하게 붙어 있다. 왜 이렇게? "어떤 도구 설계가 모델과 가장 궁합이 좋은가"를 실제로 갈아 끼워 가며 A/B 테스트하기 위해서다. 코딩 에이전트의 성능이 도구 인터페이스 설계에 크게 좌우된다는 걸 아는 팀의 접근이다.

주목 포인트 3 — 안전장치가 곁다리가 아니라 1급 시민

grok-build는 OS 커널 수준 샌드박스(Linux는 Landlock, macOS는 Seatbelt)를 nono 크레이트로 시동 시 한 번 걸고, 자식 프로세스의 네트워크는 seccomp로 개별 차단한다. 여기에 doom-loop 감지(모델이 같은 짓을 반복하면 스트림을 중간에 끊음), 27KB 분량의 권한·안전 문서(22-permissions-and-safety.md)까지. "에이전트가 내 컴퓨터에서 셸을 돌린다"는 근본 공포를 정면으로 다룬다.

중요 · 오해 방지 — 두 개의 버전 번호에 속지 말 것
"grok-build"는 저장소 이름이자, 기본 모델 이름이자, 도구 세트 이름이다 — 문맥을 구분하라

이름이 여러 겹이라 헷갈리기 쉽다. grok-build는 ① 이 저장소 이름이고, ② 사용자가 쓰는 기본 LLM 모델 이름(default_models.json)이며, ③ 자체 편집 도구 세트 이름(implementations/grok_build/)이기도 하다. 셋은 다른 층위다.

버전도 두 개다. 사용자에게 배포되는 npm 버전은 0.1.220-alpha.4(@xai-official/grok)이고, 내부 크레이트 버전(xai-grok-pager-bin)은 0.2.101이다. 실제 실행 버전 문자열은 빌드 시 GROK_VERSION 환경변수로 주입된다. 이 문서에서 "버전"은 사용자 대면 alpha 버전을 기준으로 삼는다 — 아직 알파 단계임을 잊지 말자.

3기술 스택 전체 지도

첫 번째 충격 — package.json이 주인공이 아니다. Cargo.toml 85개가 얽힌 Rust 워크스페이스다

보통 "코딩 CLI"라 하면 Node 프로젝트를 떠올리지만, grok-build의 실체는 약 85개 크레이트로 이뤄진 Cargo 워크스페이스다. npm 패키지(@xai-official/grok)는 그저 플랫폼별 바이너리를 내려받는 얇은 껍데기일 뿐이다. 스택을 이해하려면 "무엇이 화면을 그리고, 무엇이 모델과 말하고, 무엇이 안전을 지키는가"의 세 축으로 봐야 한다.

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

요소내용
TUI 프레임워크ratatui 0.29 + ratatui-core, 백엔드 crossterm 0.28. 페이저 크레이트의 ~140개 파일이 ratatui를 씀. Ink/React·Bubble Tea·Textual이 아니라 순수 Rust.
자체 위젯xai-ratatui-inline(대체 화면 안 쓰는 인라인 렌더링), xai-ratatui-textarea(여러 줄 프롬프트 편집기), tui-scrollbar.
터미널 에뮬레이션내장 터미널 도구용으로 alacritty_terminal 0.26, portable-pty 0.9, vte 0.15, termwiz 0.23, ansi-to-tui, 자체 ptyctl.
터미널 내 렌더문법 강조 syntect 5.3+two-face, 마크다운 pulldown-cmark 0.13, 이미지·PDF·SVG 래스터화(resvg/tiny-skia/image/pdf_oxide), Mermaid 다이어그램을 Rust로 직접 렌더(벤더링된 dagre_rust·mermaid-to-svg).

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

요소내용
LLM 클라이언트async-openai 0.33(responses 기능) — OpenAI 호환 Responses API로 말함. 스트리밍은 eventsource-stream(SSE).
엔드포인트기본값이 xAI로 하드코딩 — https://api.x.ai/v1(/chat/completions·/models·/stt), 인증은 accounts.x.ai/auth.x.ai(OAuth2 + 디바이스 코드). 중간에 cli-chat-proxy 백엔드도 존재.
비동기·네트워크tokio(full), reqwest 0.12(rustls·http2·socks), 리더 서버용 axum 0.8(+ws), tokio-tungstenite(웹소켓), gRPC tonic 0.14+prost 0.14, LSP 클라이언트 async-lsp 0.2.
ACP(에디터 내장)agent-client-protocol 0.10.4(unstable) — Zed 등 편집기에 임베드하는 프로토콜. 자체 래퍼 xai-acp-lib.
MCP완전한 MCP 클라이언트 — stdio·HTTP·ACP 전송, 인증 MCP 서버용 OAuth, 생존 확인, mcp_doctor 진단.

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

요소내용
Git(VCS)gix 0.83 — 순수 Rust Git 구현. 워크스페이스 버전관리·체크포인트를 담당(xai-fast-worktree·xai-hunk-tracker).
샌드박스·OSnix 0.30, nono(Linux=Landlock, macOS=Seatbelt)로 커널 강제 샌드박스, Windows는 windows 0.61(JobObjects).
상태·저장세션 저널 xai-sqlite-journal(SQLite), 캐시 moka, indexmap·dashmap·parking_lot·arc-swap.
검색·스키마퍼지 검색 nucleo(Helix 편집기 출신), 프롬프트/스킬 템플릿 minijinja 2.9, 도구 인자 스키마 jsonschema 0.30+schemars 1, Rust→TS 타입 내보내기 ts-rs.
관측·할당자opentelemetry 0.32(OTLP)·prometheus·tracing·Mixpanel(xai-mixpanel), 할당자는 jemalloc(힙 프로파일링 포함).
핵심 용어 · 왜 "Responses API"인가
OpenAI 호환 Responses API · async-openai
grok-build는 xAI 모델과 통신하면서도 OpenAI가 정한 "Responses API" 규격을 그대로 쓴다(async-openai 크레이트의 responses 기능). Responses API는 기존 Chat Completions보다 도구 호출·서버측 도구·스트리밍을 다루기에 더 현대적인 형식이다. 이렇게 "업계 표준 형식"을 채택하면, 서버가 웹검색 같은 도구를 서버측에서 직접 실행(hosted tool)하고 그 결과를 규격화된 이벤트로 흘려보낼 수 있다. 모델 해석 순서도 유연하다 — default_models.jsonapi_backend: "responses"로 박혀 있고, CLI 플래그 > 환경변수 > config.toml > 원격 설정 > 내장 기본값 순으로 모델이 결정된다.

기본 모델 카탈로그 (default_models.json 발췌)

// crates/codegen/xai-grok-models/default_models.json (요지)
{
  "grok-build": {          // ← 기본 모델
    "context_window": 500000,   // 50만 토큰
    "temperature": 0.7, "top_p": 0.95,
    "api_backend": "responses",
    "supported_in_api": false   // CLI 전용 — 공개 API로는 못 씀
  },
  "grok-4.20-multi-agent": { /* 웹검색 전용 */ },
  // 그 외: grok-4.5 / grok-4 / grok-code-fast-1 /
  //        grok-imagine-image(이미지생성) / grok-computer(컴퓨터사용) ...
}

주목할 건 "supported_in_api": false다. 기본 모델 grok-build이 CLI 안에서만 쓸 수 있고 공개 xAI API로는 호출되지 않는다. 즉 xAI가 "코딩 에이전트 전용으로 튜닝한 모델"을 도구와 묶어 제공하는 구조 — 모델과 하네스(harness)를 한 세트로 파는 전략이다.

한눈에 — "세 개의 방으로 나뉜 공장"

스택이 복잡해 보여도 뼈대는 셋이다. 전시장(TUI)ratatui로 손님(사용자)에게 결과를 예쁘게 보여주고, 전화실(모델·네트워크)async-openai로 본사(xAI 서버)와 통화하며, 작업장(도구·샌드박스)gix·nono로 실제 코드를 만지되 안전선을 지킨다. 이 세 방이 tokio 비동기 런타임이라는 컨베이어벨트로 연결돼 동시에 돌아간다. Rust를 택한 덕에 이 공장 전체가 Node 없이 도는 단일 바이너리 하나로 압축된다.

4아키텍처 심화 분석

에이전트 루프(턴 loop) → 샌드박스 → doom-loop 감지 → 리더/클라이언트까지, grok-build를 움직이는 핵심 설계 패턴

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

grok-build를 이해하는 가장 빠른 길은 "당신이 친 한 문장"이 어떤 부품들을 거쳐 "파일 수정"으로 끝나는지를 따라가는 것이다. 핵심은 두 개의 액터(actor) — 대화 전체를 관리하는 세션 액터와, 모델과 스트리밍으로 통신하는 샘플러(sampler) 액터가 명령·이벤트 채널로 대화하며 돈다.

┌──────────────────────────────────────────────────────────────────────┐ │ grok-build 실행 흐름 (대화형 TUI 기준) │ │ │ │ [사용자 입력] "로그인 버그 고쳐줘" │ │ │ (xai-grok-pager: ratatui TUI) │ │ v │ │ ┌─────────────────────────────────────────┐ │ │ │ 세션 액터 (xai-grok-shell / mvp_agent) │ ← 턴 loop의 지휘자 │ │ │ · 시스템 프롬프트 + 대화 이력 조립 │ │ │ │ · 컨텍스트 압축(compaction) │ │ │ │ · 목표 오케스트레이션(goal_*) │ │ │ └───────────────┬───────────────────────────┘ │ │ │ (요청 전송) │ │ v │ │ ┌─────────────────────────────────────────┐ SSE 스트림 │ │ │ 샘플러 액터 (xai-grok-sampler) │◀─────────── api.x.ai │ │ │ · Responses API 호출 · 재시도 · 계측 │ (토큰·도구호출· │ │ │ · doom-loop 신호 감지 → 스트림 중단 │ doom-loop 신호) │ │ └───────────────┬───────────────────────────┘ │ │ │ (도구 호출 파싱) │ │ v │ │ ┌─────────────────────────────────────────┐ │ │ │ ToolBridge (xai-grok-tools) │ ← 도구 레지스트리 │ │ │ Bash · ReadFile · Grep · SearchReplace │ │ │ │ · WebSearch · Task(서브에이전트) · lsp │ │ │ └───────────────┬───────────────────────────┘ │ │ │ (실제 실행, 단 아래 벽 안에서만) │ │ v │ │ ┌─────────────────────────────────────────┐ │ │ │ 샌드박스 (xai-grok-sandbox: nono) │ Landlock / Seatbelt │ │ │ + 자식 프로세스 네트워크 seccomp 차단 │ │ │ └───────────────┬───────────────────────────┘ │ │ │ (도구 결과를 대화 이력에 되먹임) │ │ └──────────► 세션 액터로 복귀 → 완료까지 루프 반복 │ └──────────────────────────────────────────────────────────────────────┘

한 "턴(turn)"은 이렇게 흐른다. 세션 액터가 시스템 프롬프트+대화 이력을 조립해 샘플러에 넘기면, 샘플러가 api.x.ai로 Responses API 요청을 보내 SSE(서버 전송 이벤트)로 응답을 한 조각씩 받는다. 응답에 도구 호출이 섞여 있으면 ToolBridge가 해당 도구를 실행하고(단 샌드박스 안에서), 그 결과를 다시 대화 이력에 붙여 다음 턴을 돈다. 이 반복이 --max-turns 한도 혹은 "작업 완료"까지 이어진다.

핵심 용어 · 이 저장소의 심장
턴 loop (turn loop) · ToolBridge · 액터 모델
에이전트가 "스스로 여러 단계를 수행"하는 비결은 턴 loop다(코드상 xai-grok-shell/src/agent/mvp_agent/). 한 턴 = 모델에게 한 번 묻고 → 도구를 실행하고 → 결과를 다시 붙이는 한 사이클. 이걸 여러 번 돌려 복잡한 작업을 완수한다. 여기서 ToolBridge"도구 레지스트리 + 도구 상태 + 세션 컨텍스트"를 한데 묶은 손잡이다. 재미있는 설계는 불변 Agent + 내부 가변 ToolBridge 분리 — 에이전트 정의는 못 바꾸게 얼려 두고(immutable), 실제 도구 실행 상태만 Arc+락으로 안전하게 공유·변경한다. 그리고 세션 액터와 샘플러 액터가 각자 채널로 메시지를 주고받는 액터 모델이라, 스트리밍 수신과 도구 실행·컨텍스트 압축이 서로를 막지 않고 동시에 돈다.

4-2. doom-loop 감지 — 헛도는 에이전트를 스스로 끊기

에이전트를 오래 돌리면 종종 같은 편집을 무한 반복하거나 똑같은 말을 되뇌는 "무한 루프"에 빠진다. grok-build는 이걸 서버·클라이언트 양쪽에서 잡는다. xAI 서버가 스트리밍 중 doom-loop 신호를 SSE로 흘려주면, 클라이언트의 DoomLoopSignalCollector가 그걸 모아 스트림을 도중에 끊어 낭비를 막는다.

// xai-grok-sampler — doom-loop 감지의 핵심 아이디어(요지)
// 매 재시도(attempt)마다 수집기를 "새로" 만든다 → 신호가 재시도 간 새지 않음
let collector = DoomLoopSignalCollector::new_for_attempt(attempt_idx);

while let Some(event) = sse_stream.next().await {
    collector.observe(&event);          // 서버가 준 doom-loop 신호 누적
    if collector.should_abort() && !is_final_retry {
        return Err(Aborted::DoomLoop);  // 헛돌면 스트림 중단 → 재시도
    }
    // ↑ 단, 마지막 재시도에서는 abort를 "무장 해제"해
    //   최소 한 번은 끝까지 응답을 받아낸다(disarm on final retry)
    yield_chunk(event);
}

영리한 디테일 둘. ① 수집기를 매 재시도마다 새로 만든다 — 그래야 이전 시도의 신호가 다음 시도로 새어 오작동하지 않는다. ② 마지막 재시도에서는 중단 로직을 해제한다 — 계속 끊기만 하면 아무 응답도 못 받으니, 최후엔 반드시 한 번은 완주시켜 결과를 보장한다. "안전(끊기)"과 "완결성(응답 보장)"을 재시도 예산으로 절충한 설계다.

4-3. 샌드박스 — "네트워크는 열되, 자식의 네트워크는 막는다"

에이전트가 내 컴퓨터에서 셸을 돌리는 건 무섭다. grok-build의 방어선은 nono 크레이트로 시동 시 OS 커널 수준 샌드박스를 한 번 거는 것이다(Linux=Landlock, macOS=Seatbelt). 여기엔 미묘한 균형이 있다.

샌드박스 정책 (xai-grok-sandbox) ┌────────────────────────────────────────────────────────────┐ │ 프로세스 자신의 네트워크 → [열림] │ │ 이유: 에이전트가 api.x.ai(모델)에 접속해야 하니까 │ │ │ │ 파일 접근 → [nono로 워크스페이스 범위로 제한] │ │ in-process tokio::fs + 자식 프로세스 모두 커버 │ │ │ │ 자식 프로세스(셸이 띄운 것)의 네트워크 → [seccomp로 차단] │ │ 이유: `bash`로 임의 데이터를 유출·다운로드 못 하게 │ │ │ │ 프로필: Workspace 등 설정 가능 · AUTO_ALLOW_BASH 토글 │ │ 위반 시: 구조화된 SandboxEvent로 기록 │ └────────────────────────────────────────────────────────────┘

핵심 통찰은 "에이전트 본체는 인터넷이 필요하지만(모델 접속), 그 에이전트가 띄운 자식 셸은 인터넷이 필요 없다"는 구분이다. 그래서 본체 네트워크는 열어 두되, bash가 낳은 자식 프로세스의 네트워크는 seccomp로 개별 차단해 데이터 유출·악성 다운로드를 막는다. 파일 접근은 nono로 워크스페이스 범위로 좁힌다. "필요한 만큼만 열고 나머지는 커널이 강제로 막는다"는 최소 권한 원칙의 실전 구현이다.

4-4. 리더/클라이언트 — 세션을 여러 곳에서 붙잡기

grok-build에는 leader라는 별도 프로세스가 있다(grok agent serve). 이건 axum 웹소켓 서버로, 하나의 세션을 여러 클라이언트가 ws://.../ws?server-key=...로 붙어 공유하게 한다. connect_or_spawn이 워크스페이스마다 리더를 알아서 띄우거나 재사용한다. 덕분에 원격 개발 상자(devbox)에서 세션을 띄워 두고, 데스크톱·모바일 등 여러 클라이언트가 같은 세션에 접속·지속하는 시나리오가 가능하다.

한눈 정리 · 아키텍처가 지키는 4대 설계 원칙
액터 분리 · 도구 추상화 · 커널 샌드박스 · 헛돌기 차단

액터 분리: 세션·샘플러를 채널로 분리해 스트리밍·도구실행·압축이 서로를 막지 않음. ② 도구 추상화: ToolBridge+트레이트 레지스트리로 도구를 갈아 끼움(그래서 codex·opencode 세트를 A/B). ③ 커널 샌드박스: 최소 권한을 앱 로직이 아닌 OS 커널에 맡겨 강제. ④ 헛돌기 차단: 서버 신호 기반 doom-loop 감지로 무한 루프·토큰 낭비를 끊되 최후엔 완결 보장. 네 원칙 모두 "믿을 수 있고 안전한 자율 에이전트"라는 목표에 직결된다.

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

85개 크레이트 / 133만 줄 Rust — "합성 루트(bin) → TUI → 에이전트 런타임 → 도구·샌드박스"의 층층 구조

이 저장소는 거대하지만 규칙적이다. 크레이트는 크게 세 무리 — crates/codegen/*(대부분의 알맹이), crates/common/*(공유 잎 크레이트), crates/build/*(빌드 스크립트) — 로 나뉘고, 여기에 prod/mc/*와 벤더링된 third_party/*가 붙는다. 아래는 "무엇을 먼저 읽어야 하는가" 관점의 지도다.

grok-build/ ├── README.md · LICENSE(Apache-2.0) · SECURITY.md · CONTRIBUTING.md ├── SOURCE_REV 내부 모노레포 동기화 원본 SHA ├── Cargo.toml ★ 자동 생성 워크스페이스 루트 (직접 편집 금지) ├── Cargo.lock (338KB) 전체 의존성 고정 ├── rust-toolchain.toml Rust 1.92.0 고정 (+rustfmt +clippy) ├── clippy.toml · rustfmt.toml ├── bin/protoc DotSlash로 관리되는 밀봉 protoc ├── THIRD-PARTY-NOTICES (762KB) 전 의존성 + codex/opencode 이식 고지 └── crates/ ├── codegen/ ★ CLI/TUI/에이전트의 알맹이 (~65 크레이트) │ ├── xai-grok-pager-bin/ ← 합성 루트 → `grok` 바이너리(진입점) │ ├── xai-grok-pager/ ← ratatui TUI (+ docs/user-guide 25개 + npm/) │ ├── xai-grok-shell/ ← 에이전트 런타임 · 턴loop · 3모드 진입점 │ ├── xai-grok-agent/ ← Agent 정의 + 프롬프트 + ToolBridge │ ├── xai-grok-tools/ ← 도구 구현 + 레지스트리 (편집 도구 A/B) │ ├── xai-grok-sampler/ ← 스트리밍 LLM 클라이언트 액터 + doom-loop │ ├── xai-grok-mcp/ ← MCP 클라이언트(http/stdio/acp, oauth) │ ├── xai-grok-sandbox/ ← OS 샌드박스(nono) + 자식 네트워크 seccomp │ ├── xai-grok-workspace*/ ← 파일시스템 · VCS · 프로세스 · 체크포인트 │ ├── xai-grok-voice/ ← 마이크 → xAI 스트리밍 STT 받아쓰기 │ ├── xai-grok-mermaid/·-markdown*/ ← 터미널 다이어그램·마크다운 렌더 │ ├── xai-ratatui-inline/·-textarea/ ← 자체 TUI 위젯 │ ├── xai-acp-lib/ ← 에디터 내장(Agent Client Protocol) │ └── ... config · memory · hooks · plugin-marketplace · models · update ├── common/ 공유 잎 크레이트(tool-protocol · compaction · computer-hub) └── build/xai-proto-build/ protobuf 코드 생성 ├── prod/mc/cli-chat-proxy-types/ CLI↔백엔드 챗 프록시 와이어 타입 └── third_party/ 벤더링된 Rust Mermaid 스택(dagre/graphlib)
크레이트역할
xai-grok-pager-bin합성 루트(composition root). grok 바이너리를 만드는 진입점. jemalloc 세팅, CLI 파싱, 실행 모드 분기.
xai-grok-shell하네스의 심장. 턴 loop, 세 진입점(run_stdio_agent·run_headless·run_leader), MCP 디스패치, 세션, 압축, 목표 오케스트레이션, 서브에이전트. 핵심 로직은 agent/mvp_agent/.
xai-grok-agentAgent 추상화 — AgentDefinition+PromptContext+렌더된 시스템 프롬프트+ToolBridge+압축 정책+서버측(hosted) 도구.
xai-grok-tools도구 구현 + 트레이트/레지스트리. implementations/여러 편집 도구 세트가 나란히(§6-1).
xai-grok-sampler스트리밍 LLM 클라이언트 액터 — SSE 디코드, 재시도, 계측, doom-loop 신호 처리.
xai-grok-sandboxOS 샌드박스(nono) + 자식 프로세스 네트워크 seccomp 차단. 위반은 SandboxEvent로 기록.
xai-grok-pagerratatui TUI 본체 — 스크롤백, 프롬프트, 모달, 슬래시 명령, 프로젝트 선택기, 설정, 음성 UI, diff 렌더. 25개짜리 사용자 매뉴얼도 이 안에.
한눈에 — "회사 조직도처럼 읽어라"

크레이트가 85개나 되니 겁먹기 쉽지만, 이름 규칙만 알면 조직도처럼 읽힌다. xai-grok-*제품 핵심 부서(pager=화면, shell=런타임, tools=실무, sandbox=보안팀), xai-ratatui-*·xai-tty-*사내 자체 제작 부품, *-types로 끝나는 크레이트는 부서 간 계약서(타입 정의)다. 타입 크레이트를 따로 두는 건 Rust 대형 프로젝트의 정석 — "화면 코드가 도구 코드의 세부를 못 건드리게" 층 경계를 컴파일러가 강제하게 만든다.

6학습 포인트

이 저장소에서 "Grok CLI 사용법"이 아니라 "프로덕션급 Rust 에이전트 아키텍처"로 가져갈 것들

배울 것 1 — 교체 가능한 "편집 도구 세트"라는 발상

xai-grok-tools/src/implementations/에는 여러 벌의 편집 도구가 나란히 산다 — 자체 grok_build(주 편집 도구는 SearchReplaceTool), 더 간결한 grok_build_concise, 실험적 grok_build_hashline, OpenAI codexapply_patch 이식, opencode 이식. 이렇게 도구를 트레이트 뒤로 추상화해 통째로 갈아 끼우는 전략 패턴은, "어떤 편집 인터페이스가 모델과 궁합이 좋은가"를 실측하려는 팀의 무기다. 코딩 에이전트 성능이 도구 설계에 크게 좌우된다는 실무 감각을 배운다.

배울 것 2 — 해시라인(hashline) 편집: 자가 치유하는 코드 수정

가장 새로운 아이디어. 보통 에이전트는 "이 정확한 문자열을 저 문자열로 바꿔라"(exact string match)로 코드를 고치는데, 파일이 조금만 바뀌어도 실패한다. grok_build_hashline각 줄을 해시로 "닻(anchor)"을 걸어 편집한다. AnchorScheme 트레이트에 세 가지 후보 방식(A/B/C)이 있고, 닻이 어긋나거나 낡았을 때 제한된 범위에서 스스로 복구한다. 자체 벤치마크 하네스까지 딸려 있다 — "깨지기 쉬운 문자열 매칭"을 "자가 치유 편집"으로 바꾸는 접근을 실물로 볼 수 있다.

배울 것 3 — 액터 모델로 짜는 스트리밍 에이전트

세션 액터 + 샘플러 액터가 명령·이벤트 채널로 대화하는 구조. SSE 디코드(1층)와 스트림 변환(2층)을 분리하고, 컨텍스트 압축을 spawn_local 태스크로 돌려 턴 loop와 경쟁하지 않게 한다. "동시성이 필요한 실시간 시스템을 Rust tokio로 어떻게 깔끔히 쪼개는가"의 교보재다.

배울 것 4 — OS 커널 샌드박스를 앱에 붙이기

nono로 Landlock(Linux)·Seatbelt(macOS)를 걸고, 자식 프로세스 네트워크를 seccomp로 개별 차단하는 실전 코드. "에이전트 본체 네트워크는 열고, 자식 셸 네트워크는 막는다"는 비대칭 정책 설계는, 자동화 도구를 만들 누구에게나 값진 보안 사고 훈련이다.

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

85개 크레이트, 자동 생성되는 읽기 전용 루트 Cargo.toml, *-types 크레이트로 강제하는 층 경계, rust-toolchain.toml로 못 박은 툴체인(1.92.0), DotSlash로 밀봉한 protoc, per-target rustflags 튜닝. "Rust 모노레포를 어떻게 재현 가능하고 일관되게 유지하는가"의 모범 사례.

배울 것 6 — 하나의 바이너리, 세 개의 실행 모드 + 표준 프로토콜

같은 코어를 대화형 TUI · 헤드리스(grok agent) · 에디터 내장(ACP)으로 노출하는 설계. 특히 MCP(도구 연결)ACP(에디터 연결) 같은 업계 표준 프로토콜을 클라이언트로 구현한 부분은, "내 도구를 남의 생태계에 끼워 넣는 법"을 배우기에 좋다.

한 줄 정리 · 재사용 가능한 교훈
"grok-build의 진짜 교재 가치는 'Grok 쓰는 법'이 아니라 '자율 에이전트를 안전하고 빠르게 짜는 Rust 아키텍처'다"

모델이 Grok이든 무엇이든, 이 저장소가 남기는 원칙은 보편적이다. 도구를 추상화해 갈아 끼우고, 스트리밍을 액터로 쪼개고, 안전을 커널에 맡기고, 헛돌기를 신호로 끊어라. 여기에 "표준 프로토콜(MCP·ACP·Responses API)로 남의 생태계와 붙어라"까지. 코딩 에이전트를 직접 만들 생각이 없어도, 신뢰성·안전·성능을 동시에 챙겨야 하는 시스템 설계자라면 뜯어볼 값어치가 크다.

7시스템 · 실행 요구사항

두 갈래로 나뉜다 — "그냥 쓰기(바이너리 설치)"와 "소스에서 직접 빌드하기(Rust 툴체인)"

대부분의 사용자는 바이너리를 내려받아 쓰면 되므로 요구사항이 가볍다. 반면 소스에서 빌드하려면 Rust 툴체인과 밀봉 도구들이 필요하다. 아래 표가 두 경로를 가른다.

항목요구/수치
설치(권장)공식 설치 스크립트 — curl -fsSL https://x.ai/cli/install.sh | bash(macOS/Linux/Git Bash), Windows는 irm https://x.ai/cli/install.ps1 | iex. 버전 고정·채널 지정 가능.
설치(npm)@xai-official/grok(v0.1.220-alpha.4) — 플랫폼별 선택적 의존성(grok-darwin-arm64 등)으로 바이너리를 붙이는 얇은 래퍼. postinstall.js가 맞는 바이너리 선택. Node ≥ 20 필요.
계정·인증브라우저 OAuth2(accounts.x.ai) 로그인 → 자격증명은 ~/.grok/auth.json에 캐시·자동 갱신. 헤드리스는 디바이스 코드 흐름, 또는 XAI_API_KEY 환경변수. (Grok 사용에는 유료 크레딧/구독이 필요할 수 있음.)
빌드(소스)Rust 툴체인 1.92.0 고정(rust-toolchain.toml) + DotSlash(bin/protoc 밀봉 실행) + protoc. 빌드 호스트는 macOS/Linux 지원, Windows 빌드는 best-effort(미검증). 실행: cargo run -p xai-grok-pager-bin.
자체 업데이트grok update 내장 — --alpha/--stable/--enterprise 채널, 최소 버전 강제.
주요 CLI 명령grok(TUI), grok agent(헤드리스), grok leader(세션 서버), login/logout·mcp·plugin·memory·models·sessions·setup·share·wrap·export·trace·update.
한눈 요약 — "완제품을 살까, 부품으로 조립할까"

비유하면 설치 스크립트/npm은 "완제품 구매"다 — 내려받아 로그인하면 끝, Rust를 몰라도 된다. 반면 소스 빌드는 "부품 조립 키트"라 Rust 1.92.0·DotSlash·protoc라는 공구가 필요하다. 대다수는 완제품으로 충분하고, "소스가 진짜 어떻게 도는지 뜯어보고 싶은 사람"만 조립 경로로 간다 — 이 미러를 공개한 목적 자체가 후자를 위한 것이다.

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

난이도별 — "설치·체험 → 헤드리스 자동화 → 소스 읽기 → 샌드박스 확인 → 도구 세트 비교"

먼저 설치. 스크립트가 가장 간단하다.

# 설치 (택1)
curl -fsSL https://x.ai/cli/install.sh | bash        # macOS/Linux
# 또는  npm i -g @xai-official/grok                 # Node ≥ 20

grok            # 대화형 TUI 실행 → 브라우저 OAuth 로그인
실습 1 · 난이도 ★☆☆☆☆

TUI로 작은 리팩터링 한 번 시켜 보기 — 에이전트 루프 체감

아무 작은 저장소에서 grok을 띄우고 "이 함수에 주석 달아줘" 정도를 시켜 본다. 에이전트가 파일을 읽고(Read) → 고치고(SearchReplace) → diff를 보여주는 흐름을, §4-1 구조도와 대조하며 눈으로 확인한다. 슬래시 명령(/)과 @파일 참조도 눌러 본다.

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

헤드리스 모드로 스크립트에 에이전트 심기 — grok agent

grok agent를 셸 스크립트에서 호출해, 사람 개입 없이 "README의 오탈자를 고쳐 PR 문구를 출력" 같은 작업을 자동화한다. --max-turns로 상한을 두고, 출력이 어떻게 파이프라인에 쓰이는지 확인. CI에서 에이전트를 부르는 감을 익힌다.

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

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

git clone --depth 1로 미러를 받아 crates/codegen/xai-grok-shell/src/agent/mvp_agent/를 연다. "모델 호출 → 도구 파싱 → 결과 되먹임"의 흐름과 ToolBridge가 어디서 도구를 실행하는지 따라가 본다. xai-grok-tools/src/implementations/mod.rs에서 어떤 도구들이 등록되는지도 확인.

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

샌드박스가 진짜 막는지 실험 — 자식 네트워크 차단 확인

에이전트에게 "curl로 외부 주소에 접속해봐" 같은 셸 작업을 시켜, 자식 프로세스 네트워크가 seccomp로 막히는지 관찰한다(18-sandbox.md·22-permissions-and-safety.md 참조). 반대로 에이전트 본체는 api.x.ai에 잘 붙는 비대칭 정책을 눈으로 확인. 주의: 실험은 안전한 테스트 디렉토리에서.

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

편집 도구 세트 A/B 비교 — grok_build vs codex vs hashline

xai-grok-tools/src/implementations/grok_build·codex·grok_build_hashline 세 세트를 소스로 비교한다. 각 세트가 "코드 수정"을 어떻게 다르게 표현하는지(SearchReplace vs apply_patch vs 해시 앵커), 그리고 hashline의 AnchorScheme이 어긋난 닻을 어떻게 복구하는지 읽어 낸다. "도구 인터페이스 설계가 에이전트 성능을 어떻게 바꾸는가"에 대한 자기만의 가설을 세워 본다.

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

grok-build를 정복하며 곁들여 익히면 좋은 것들 — 주차별 5단계
주차주제 · 목표
1주차에이전트 루프의 기본기. "생각→도구 호출→관찰→반복"의 ReAct식 루프, 도구 스키마(JSON Schema), 시스템 프롬프트 조립. 목표: §4-1 구조도를 스스로 그릴 수 있게.
2주차Rust 비동기·액터. tokio 태스크·채널(mpsc), 그리고 액터 패턴으로 스트리밍 시스템을 쪼개는 법. xai-grok-sampler의 SSE 처리를 읽을 수 있게.
3주차TUI 만들기 — ratatui. ratatui+crossterm으로 전체 화면·위젯·이벤트 루프를 다뤄 본다. 인라인 렌더링과 문법 강조(syntect)까지.
4주차OS 샌드박스·보안. Linux Landlock·seccomp, macOS Seatbelt의 원리와 nono 크레이트. "자동화 도구에 최소 권한을 커널로 강제"하는 실전.
5주차에이전트 상호운용 프로토콜. MCP(도구 연결)·ACP(에디터 연결)·OpenAI Responses API를 클라이언트로 구현·소비하는 법. "내 에이전트를 남의 생태계에 끼우기"를 완성.

10핵심 키워드 사전

이 문서와 저장소에서 반복되는 용어 빠른 참조
용어
grok-build세 층위의 이름 — ① 이 저장소, ② 기본 LLM 모델(50만 토큰·CLI 전용), ③ 자체 편집 도구 세트. 명령어는 grok.
TUI · ratatui터미널 안에 글자로 그리는 전체 화면 UI / 그걸 그리는 Rust 라이브러리(0.29). Ink(JS)가 아니라 순수 Rust.
턴 loop (turn loop)모델 호출→도구 실행→결과 되먹임의 한 사이클. 여러 번 돌려 복잡한 작업을 자율 수행. 코드상 mvp_agent/.
ToolBridge도구 레지스트리+상태+세션 컨텍스트를 묶은 손잡이. 불변 Agent + 내부 가변 ToolBridge로 분리.
편집 도구 세트교체 가능한 도구 묶음 — grok_build(SearchReplace)·codex(apply_patch)·opencode·hashline. A/B 실험용.
hashline 편집줄을 해시로 앵커링해 편집하고, 닻이 어긋나면 스스로 복구하는 자가 치유 편집. AnchorScheme 트레이트.
doom-loop에이전트가 같은 짓을 반복하는 무한 루프. 서버 신호를 SSE로 받아 스트림을 중단(단 최후 재시도는 완주 보장).
샌드박스 (nono)커널 강제 격리 — Linux=Landlock, macOS=Seatbelt. 본체 네트워크는 열되 자식 프로세스 네트워크는 seccomp로 차단.
Responses APIOpenAI가 정한 현대적 대화·도구 호출 형식. grok-build는 xAI 모델에도 이 규격(async-openai)으로 접속.
MCP · ACP각각 도구 연결(Model Context Protocol) · 에디터 내장(Agent Client Protocol, Zed식) 표준. grok-build는 둘 다 클라이언트로 구현.
leader세션을 웹소켓으로 여러 클라이언트에 공유하는 서버 프로세스(grok agent serve). 원격/멀티 접속 지원.
gix / DotSlash순수 Rust Git 구현(체크포인트·워크트리) / 빌드에 쓰는 밀봉 도구 실행기(bin/protoc). 재현 가능한 빌드용.
공개 미러 · SOURCE_REV내부 모노레포에서 동기화되는 읽기 전용 거울(PR 미수용). 원본 SHA는 SOURCE_REV에 기록, 커밋은 전부 "Synced from monorepo".

11참고 링크

공식 소스 우선 — 버전·수치는 클론한 소스(npm v0.1.220-alpha.4, 커밋 8adf901) 기준

공식
· GitHub 저장소: github.com/xai-org/grok-build (Apache-2.0 · © 2023-2026 SpaceXAI · 내부 모노레포 미러)
· TrendShift 카드: trendshift.io/repositories/83820 (Daily #1 · #AI agent · #AI coding assistant)
· 설치: curl -fsSL https://x.ai/cli/install.sh | bash 또는 npm i -g @xai-official/grok

저장소 안에서 꼭 읽을 것
· crates/codegen/xai-grok-shell/src/agent/mvp_agent/ — 턴 loop(하네스의 심장)
· crates/codegen/xai-grok-tools/src/implementations/ — 교체 가능한 편집 도구 세트들(codex·opencode·hashline)
· crates/codegen/xai-grok-sampler/ — 스트리밍 샘플러 + doom-loop 감지
· crates/codegen/xai-grok-sandbox/src/lib.rs — nono 샌드박스 + seccomp
· crates/codegen/xai-grok-pager/docs/user-guide/ — 25개짜리 공식 사용자 매뉴얼(권한·안전 포함)

곁들여 학습
· ratatui · crossterm — Rust TUI 프레임워크 문서
· tokio 액터 패턴 · 채널(mpsc) · SSE 스트리밍
· Linux Landlock · seccomp / macOS Seatbelt — OS 샌드박스
· OpenAI Responses API · MCP(Model Context Protocol) · ACP(Agent Client Protocol) 규격
· 이미 분석한 다른 터미널 코딩 에이전트 딥다이브들과 비교(§인덱스 cat-coding-cli)

참고 · 소스 정독으로 확인한 주의점
"공개 미러 + 알파"라는 성격을 잊지 말 것

① 이 저장소는 내부 모노레포의 읽기 전용 미러다 — 커밋 히스토리가 단 하나("Synced from monorepo")로 뭉개져 있어 변경 이력 추적은 불가하고, PR도 받지 않는다. ② 사용자 버전은 아직 알파(0.1.220-alpha.4)이며 내부 크레이트 버전(0.2.101)과 다르다. ③ 기본 모델 grok-build공개 API로 못 쓰고 이 CLI 안에서만 동작한다(supported_in_api:false). ④ Windows 소스 빌드는 미검증(best-effort). ⑤ 트리에 codex·opencode 코드가 이식돼 있어 Apache §4(b) 변경 고지가 붙는다. ⑥ 이 문서 수치는 분석 시점 최신 커밋(2026-07-16, 8adf901) 기준이며, 트렌딩 특성상 순위·지표는 계속 바뀐다.