context-mode를 쓰면 도구 출력이 98% 줄어든다는데, 과연 진짜일까?

Q: context-mode를 쓰면 도구 출력이 98% 줄어든다는데, 과연 진짜일까?

137,851바이트 pytest 출력 명령을 지정하자 Claude는 잘린 Bash 결과를 먼저 받고 context-mode 도구로 다시 실행해 입력 토큰이 줄지 않았고 비용 추정은 2.2배였으며, 명령을 맡기면 플러그인 구성은 그 도구를 쓰지 않았다.

이번 시간에는 큰 명령 출력을 샌드박스에 두고 필요한 부분만 돌려준다는 context-mode가 Claude Code에서 실제로 토큰을 줄이는지를 claude -p로 측정하며 배워가는 시간입니다. claude -p는 대화 화면 없이 질문 하나를 보내고 결과를 받는 실행 방식이에요.

실패하는 테스트가 있는 작은 Python 프로젝트로, 큰 출력이 나오는 명령을 지정한 과제와 명령을 Claude에게 맡긴 과제를 도구 없는 조건과 번갈아 보내 볼게요. 모델 출력은 비결정적이라 다시 돌리면 숫자가 달라질 수 있어요.

context-mode가 줄이는 것과 공개 수치

context-mode(mksglu/context-mode)는 명령을 MCP 서버 안에서 실행하는 ctx_execute, ctx_batch_execute 같은 도구 11개와, Claude가 그 도구를 고르도록 안내하는 hook(도구 호출 앞뒤에 도는 스크립트)을 함께 설치해요. 원본 출력은 서버의 검색 색인에 남고 Claude에게는 코드가 찍은 결과나 검색에 걸린 부분만 갑니다.

README의 "315 KB of raw output becomes 5.4 KB"(98%)는 BENCHMARK.md를 보면 미리 저장해 둔 출력을 이 도구들에 넣어 바이트를 비교한 값이에요. 일반 Bash 명령은 막지 않고 안내만 하니, 실제로 줄어드는지는 Claude가 ctx_* 도구를 고르는지에 달려 있습니다.

실습 준비

이 글의 명령은 모두 실습 코드의 context-mode-sandbox-output/ 디렉터리에서 실행합니다.

평소에는 Claude Code 안에서 플러그인으로 설치해요.

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

이번 측정은 Mac에 아무것도 설치하지 않으려고 Docker로 감쌌어요.

컨테이너 하나(cm-lab)에서 MCP 서버와 hook을 모두 docker exec로 실행합니다. 서버 이름은 hook 안내문이 가리키는 플러그인 도구 이름(mcp__plugin_context-mode_context-mode__ctx_execute)에 맞춰 plugin_context-mode_context-mode로 지었어요.
도구 없는 조건의 Bash도 python, pytest는 같은 컨테이너에서 돌게 했어요. CLAUDE_ENV_FILE(Claude Code가 Bash 명령마다 먼저 읽는 셸 파일)이 docker exec로 넘기는 bin/을 PATH 맨 앞에 둡니다. 그래서 이 명령들과 hook에는 docker exec 지연이 붙고, find 같은 나머지 명령은 Bash에서는 macOS 명령, ctx_*에서는 busybox로 돌아요.

실습 파일은 이렇습니다.

Dockerfile, setup.sh: 이미지를 만들고 실습 프로젝트, bin/, MCP 설정, 공식 지침 guide-CLAUDE.md를 만드는 스크립트
gen_project.py: 고정 시드로 실습 프로젝트 pristine/과 정답 truth.json을 만드는 스크립트
hooks-settings.json: 플러그인의 hook 6종을 docker exec로 옮긴 프로젝트 설정
lab.sh, run.sh, schedule.txt, prompt-a.txt, prompt-b.txt: 조건별 호출 함수, 순서대로 30번 호출하는 스크립트, 호출 순서, 두 과제의 질문
direct.sh, mcp_call.mjs: Claude 없이 서버 도구를 직접 불러 출력 크기를 재는 스크립트
summarize.mjs, calls.mjs: 결과를 조건별로 모으는 스크립트와 호출 하나의 도구 사용을 보여 주는 스크립트
README.md: 파일 목록

집계 스크립트는 Node로 돌리니 셸 함수 하나를 만들어 둘게요. 아래 블록은 파일로 만들지 말고 실습 디렉터리에서 연 터미널에 그대로 붙여 넣어 주세요. 이후 명령은 모두 이 터미널에서 실행하고, 터미널을 새로 열면 다시 붙여 넣으시면 됩니다.

node24() { docker run --rm --network none -v "$PWD":/w -w /w node:24-alpine node "$@"; }

zip에서 푼 스크립트는 실행 권한이 없어서 먼저 chmod +x로 붙여 줍니다. 만든 MCP 설정도 같이 볼게요(발췌, 이미지 ID 줄과 정답 줄을 빼고 실습 디렉터리 경로를 가렸어요).

chmod +x setup.sh run.sh direct.sh
./setup.sh
cat mcp-hooks.json

pristine/: 주문 400건, 테스트 케이스 240개, 값이 달라지는 주문 ['O-51841']
준비 완료: bin/, envfile.sh, mcp-hooks.json, mcp-guide.json, guide-CLAUDE.md
{
  "mcpServers": {
    "plugin_context-mode_context-mode": {
      "command": "docker",
      "args": ["exec", "-i", "-w", "<실습 디렉터리>/work", "-e", "CLAUDE_PROJECT_DIR=<실습 디렉터리>/work", "cm-lab", "context-mode"]
    }
  }
}

테스트는 line_total 케이스 240개와 다른 테스트 6개예요. bulk_discount가 "100개 이상"이 아니라 "100개 초과"에 할인을 줘서, 수량이 정확히 100인 케이스 하나와 주문 보고서 테스트 하나가 실패해요.

lab.sh의 ask가 부르는 명령은 이렇습니다(발췌).

  (cd "$W" && CLAUDE_ENV_FILE="$LAB/envfile.sh" ENABLE_TOOL_SEARCH=true MCP_TIMEOUT=60000 \
    perl -e 'alarm shift; exec @ARGV' 900 \
    claude -p "$(cat "$LAB/$prompt")" --tools "Bash,Read,Grep,Glob,ToolSearch" ${extra[@]+"${extra[@]}"} \
      --model opus --effort medium \
      --setting-sources project --strict-mcp-config \
      --allowedTools "$allowed" \
      --no-session-persistence --output-format stream-json --verbose --include-hook-events \
      < /dev/null) > "$out" 2> "${out%.jsonl}.err"

perl 줄은 호출이 15분을 넘으면 끊고, MCP_TIMEOUT은 서버 연결을 60초까지 기다리게 해요. 조건은 세 가지이고, extra와 allowed에 붙는 것만 달라요.

base: 도구 없음. Bash, Read, Grep, Glob, ToolSearch만 줍니다.
hooks: 플러그인 설치와 같은 구성. work/.claude/settings.json에 hook 설정을 두고 --mcp-config mcp-hooks.json을 붙여요.
guide: hook 없이 --mcp-config mcp-guide.json(서버 이름 context-mode)과, 패키지에 든 공식 지침 configs/claude-code/CLAUDE.md를 work/CLAUDE.md로 둡니다. README는 hook 없이 이렇게 쓰면 약 60% 절감이라고 적었어요.

tool search(MCP 도구 정의를 필요할 때만 불러오는 기능)는 Claude Code 기본값이라 세 조건 모두 켰어요. 호출마다 컨테이너와 work/를 새로 만들어 앞 호출의 색인과 세션 기록이 남지 않게 했습니다.

실습 1: 큰 출력이 나오는 명령을 지정했을 때

첫 과제는 도구 저자의 벤치마크처럼 큰 출력이 반드시 나오도록 명령을 정해 줍니다.

cat prompt-b.txt

이 디렉터리에서 `python -m pytest -vv` 명령을 실행하고, 그 출력만으로 아래 세 질문에 답해 주세요. 명령을 바꾸거나 파이프로 출력을 줄이지 말고 그대로 실행해 주세요. 소스 코드와 데이터 파일은 열지 마세요.

1. 실패한 테스트의 pytest 노드 ID는 무엇인가요?
2. test_report_matches_expected에서 값이 다른 주문 번호와, 그 주문의 실제 값과 기대값은 얼마인가요?
3. test_line_total[c171]에서 line_total이 돌려준 실제 값은 얼마인가요?

답의 맨 마지막 줄에는 {"failing": ["노드 ID", ...], "order": "주문 번호", "actual": 숫자, "expected": 숫자, "c171_actual": 숫자} 형식의 JSON 한 줄만 적어 주세요.

먼저 Claude 없이 원본 출력과 서버 도구를 거친 출력을 재 볼게요. direct.sh는 컨테이너에서 pytest(raw-v.txt)와 pytest -vv(raw-vv.txt)를 그대로 실행하고, 같은 명령을 서버에 직접 보내요. ctx-v.txt는 ctx_execute에 intent(무엇을 찾는지 적는 인자) 없이 한 번, ctx-v-intent.txt는 "which tests failed and why"를 주고 한 번, ctx-vv.txt는 -vv를 intent 없이, batch-vv.txt는 ctx_batch_execute에 검색어 "FAILED test", "Differing items"를 준 결과예요.

./direct.sh
grep -c "c171" out/direct/raw-v.txt out/direct/ctx-v-intent.txt

    5936 out/direct/batch-vv.txt
    1325 out/direct/ctx-v-intent.txt
   60000 out/direct/ctx-v.txt
     737 out/direct/ctx-vv.txt
   59969 out/direct/raw-v.txt
  137851 out/direct/raw-vv.txt
  265818 total
out/direct/raw-v.txt:4
out/direct/ctx-v-intent.txt:0

ctx_execute는 intent가 없으면 60KB 출력을 줄이지 않았어요(59,969바이트가 60,000바이트). intent를 주면 1,325바이트로 줄었지만 실패한 테스트 c171이 빠졌고, 138KB인 -vv 출력은 소스의 기준값 100KB를 넘어 색인한 뒤 737바이트 요약만 돌려줬습니다.

같은 -vv 명령의 원본과 ctx_batch_execute 결과를 나란히 볼게요(발췌). 원본은 2,303줄 가운데 676번째 줄에 값이 다른 주문이 있어요.

sed -n '676,677p' out/direct/raw-vv.txt
head -n 12 out/direct/batch-vv.txt
grep -n "O-51841" out/direct/batch-vv.txt

E         Differing items:
E         {'O-51841': 5052.0} != {'O-51841': 4546.8}
Executed 1 commands (2309 lines, 134.7KB). Indexed 5 sections. Searched 2 queries.

## Commands

- pytest run: `python -m pytest -vv`

## Indexed Sections

- pytest run (1) (0.4KB)
- pytest run (2) (19.2KB)
- pytest run (3) (0.7KB)
- pytest run (4) (41.5KB)
92:  {'O-51841': 5052.0} != {'O-51841': 4546.8}
132:E         {'O-51841': 5052.0} != {'O-51841': 4546.8}

ctx_batch_execute는 출력 전체를 구역으로 나눠 색인하고, 검색어에 걸린 부분만 붙여 137,851바이트를 5,936바이트로 줄였어요(95.7% 감소).

이제 run.sh로 schedule.txt의 순서대로 30번 호출해요. 회차 번호 0인 조건별 첫 호출은 준비 호출이라 집계에서 뺍니다.

./run.sh

b base 0
b hooks 0
b guide 0

summarize.mjs는 회차마다 정답 여부(truth.json과 답의 마지막 JSON 비교), 부른 도구, 도구 결과 글자 수, 입력 토큰(입력 세 필드의 합) 등을 찍고 중앙값을 냅니다.

node24 summarize.mjs b

b/base: 6회, 정답 5/6, ctx 도구를 쓴 회차 0
  run-1.jsonl: O, Bash Bash Grep Grep, 결과 13,776자, 입력 63,790, $0.0608, 5턴, 49.2초
  run-2.jsonl: X, Bash, 결과 10,040자, 입력 20,191, $0.0325, 2턴, 21.2초
  run-3.jsonl: O, Bash Bash Grep Grep Grep, 결과 20,402자, 입력 86,514, $0.0988, 6턴, 30.6초
  run-4.jsonl: O, Bash Bash Grep Grep Read, 결과 36,200자, 입력 98,399, $0.1780, 6턴, 25.3초
  run-5.jsonl: O, Bash Bash Grep Grep Read Read, 결과 14,569자, 입력 79,041, $0.0704, 7턴, 23.2초
  run-6.jsonl: O, Bash Bash Grep Grep, 결과 19,713자, 입력 56,564, $0.0881, 5턴, 26.2초
  중앙값: 결과 17,141자, 입력 71,416, $0.0792, 5.5턴, 25.8초
b/hooks: 6회, 정답 6/6, ctx 도구를 쓴 회차 6
  run-1.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 22,920자, 입력 71,206, $0.1633, 4턴, 30.5초
  run-2.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 25,767자, 입력 72,428, $0.1722, 4턴, 23.6초
  run-3.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 26,380자, 입력 72,810, $0.1765, 4턴, 24.4초
  run-4.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 33,955자, 입력 75,754, $0.2025, 4턴, 22.5초
  run-5.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 24,596자, 입력 71,828, $0.1694, 4턴, 20.9초
  run-6.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 26,425자, 입력 72,758, $0.1745, 4턴, 22.2초
  중앙값: 결과 26,074자, 입력 72,593, $0.1733, 4턴, 23.0초
b/guide: 6회, 정답 6/6, ctx 도구를 쓴 회차 5
  run-1.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 30,102자, 입력 74,920, $0.1886, 4턴, 25.0초
  run-2.jsonl: O, Bash ToolSearch ctx_execute, 결과 42,330자, 입력 81,005, $0.2405, 4턴, 39.2초
  run-3.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 25,384자, 입력 72,705, $0.2103, 4턴, 21.1초
  run-4.jsonl: O, Bash Bash Grep Bash, 결과 13,076자, 입력 77,545, $0.1049, 5턴, 22.6초
  run-5.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 25,466자, 입력 73,403, $0.1798, 4턴, 22.6초
  run-6.jsonl: O, Bash ToolSearch ctx_batch_execute, 결과 28,749자, 입력 74,220, $0.1832, 4턴, 20.3초
  중앙값: 결과 27,108자, 입력 74,570, $0.1859, 4턴, 22.6초

hooks는 6번 모두 ctx_batch_execute를 불렀고 정답도 모두 맞혔어요. 그런데 입력 토큰 중앙값은 base 71,416, hooks 72,593, guide 74,570으로 거의 같고, 비용 추정 중앙값은 hooks가 2.2배($0.1733 대 $0.0792)예요. 턴 수는 hooks가 4번으로 base의 5.5번보다 적었습니다.

왜 그럴까요? calls.mjs로 base와 hooks의 1회차를 볼게요. 부른 도구와 인자, 결과 글자 수를 순서대로 찍습니다.

node24 calls.mjs out/b/base/run-1.jsonl
node24 calls.mjs out/b/hooks/run-1.jsonl

1. Bash {"command":"python -m pytest -vv"} -> 10,040자, 중간 20,012자 잘림
2. Bash {"command":"python -m pytest -vv > /tmp/pytest_full_out.txt 2>&1; echo exit=$?; wc -l /tmp/pytest_full_out.txt"} -> 40자
3. Grep {"pattern":"FAILED|ERROR|c171|^E  |Differing|!=|^>|assert","path":"/tmp/pytest_full_out.txt","output_mode":"content","head_limit":80} -> 3,089자
4. Grep {"pattern":"Differing|Left contains|Right contains|^E         \\{'O-\\d+': [\\d.]+\\} != |short test summary|^FAILED|passed|failed","path":"/tmp/pytest_full_out.txt","output_mode":"content","-A":2} -> 607자
1. Bash {"command":"python -m pytest -vv"} -> 10,040자, 중간 20,012자 잘림
2. ToolSearch {"query":"select:mcp__plugin_context-mode_context-mode__ctx_batch_execute,mcp__plugin_context-mode_context-mode__ctx_search","max_results":2} -> 0자
3. ctx_batch_execute {"commands":[{"label":"pytest -vv full output","command":"python -m pytest -vv"}],"queries":["FAILED short test summary info","test_line_total[c171] assert","Differing items","test_report_matches_expected AssertionError"],"cwd":"."} -> 12,880자

두 조건 모두 처음에는 지시받은 명령을 Bash로 실행했어요. Claude Code는 137,851바이트 중 앞 30,000자 안의 머리 5,000자와 꼬리 5,000자만 남긴 10,040자를 줬어요. 잘림 표시는 20,012자지만 30,000자 뒤 약 108KB는 표시 없이 빠졌고, 실패 내용과 값이 다른 주문은 그 안에 없었습니다.

그다음이 갈렸어요. base는 출력을 파일로 저장해 Grep으로 찾았고, hooks는 ctx_batch_execute로 명령을 한 번 더 실행해 검색 결과 12,880자를 받았어요. 잘린 10,040자를 이미 받은 뒤라, 도구는 원본을 다시 읽는 방법만 바꾼 셈입니다.

base 2회차는 "명령을 바꾸지 말라"는 지시 때문에 다시 실행하지 않고 값을 모두 null로 적어 틀렸어요.

비용은 왜 2.2배일까요? 두 1회차의 결과 JSON에서 턴 수, 비용, usage 네 필드만 뽑아 볼게요(발췌).

tail -n 1 out/b/base/run-1.jsonl | jq -c '{num_turns, total_cost_usd, usage: (.usage | {input_tokens, cache_creation_input_tokens, cache_read_input_tokens, output_tokens})}'
tail -n 1 out/b/hooks/run-1.jsonl | jq -c '{num_turns, total_cost_usd, usage: (.usage | {input_tokens, cache_creation_input_tokens, cache_read_input_tokens, output_tokens})}'

{"num_turns":5,"total_cost_usd":0.0607508,"usage":{"input_tokens":10,"cache_creation_input_tokens":2566,"cache_read_input_tokens":61214,"output_tokens":1397}}
{"num_turns":4,"total_cost_usd":0.163323,"usage":{"input_tokens":8,"cache_creation_input_tokens":15863,"cache_read_input_tokens":55335,"output_tokens":1266}}

hooks는 턴이 하나 적었지만 도구 정의와 검색 결과를 새로 캐시에 써서, 캐시 쓰기가 15,863으로 base의 2,566보다 6배 많았어요. 입력 토큰 합은 캐시 쓰기와 그보다 40배 싼 캐시 읽기를 같은 1토큰으로 세서 이 차이를 가립니다.

base는 6번 모두 첫 Bash 결과(5,455토큰)를 앞 호출이 써 둔 캐시에서 읽어 싸게 나오기도 했어요. 그 몫을 새로 썼다고 치고 다시 계산해도(결과 JSON에서 맞춘 단가, 캐시 쓰기 100만 토큰당 $8, 읽기 $0.2) base 중앙값은 $0.1218로 hooks가 약 1.4배였고, 캐시가 비어 있던 준비 호출끼리는 $0.2250 대 $0.1258로 1.8배였습니다.

실습 2: 명령을 Claude에게 맡겼을 때

두 번째 과제는 실제 사용처럼 명령을 정하지 않아요. prompt-a.txt는 테스트를 실행해 실패한 테스트와 원인이 된 파일·함수를 찾고, 마지막 줄에 {"failing": [...], "file": ..., "function": ...} JSON을 적게 합니다.

node24 summarize.mjs a

a/base: 3회, 정답 3/3, ctx 도구를 쓴 회차 0
  run-1.jsonl: O, Bash Bash Bash, 결과 8,370자, 입력 40,904, $0.0924, 4턴, 24.2초
  run-2.jsonl: O, Bash Bash Bash, 결과 6,620자, 입력 37,919, $0.0704, 4턴, 19.2초
  run-3.jsonl: O, Bash Bash Bash, 결과 7,029자, 입력 38,349, $0.0658, 4턴, 18.7초
  중앙값: 결과 7,029자, 입력 38,349, $0.0704, 4턴, 19.2초
a/hooks: 3회, 정답 3/3, ctx 도구를 쓴 회차 0
  run-1.jsonl: O, Bash Bash Bash, 결과 7,265자, 입력 50,435, $0.0959, 4턴, 27.1초
  run-2.jsonl: O, Bash Bash Bash, 결과 6,519자, 입력 49,805, $0.0663, 4턴, 20.8초
  run-3.jsonl: O, Bash Bash Bash Bash, 결과 6,305자, 입력 63,106, $0.0731, 5턴, 34.9초
  중앙값: 결과 6,519자, 입력 50,435, $0.0731, 4턴, 27.1초
a/guide: 3회, 정답 3/3, ctx 도구를 쓴 회차 3
  run-1.jsonl: O, ToolSearch ctx_execute ctx_execute ctx_execute, 결과 3,414자, 입력 71,484, $0.1210, 5턴, 23.1초
  run-2.jsonl: O, ToolSearch ctx_execute ctx_execute, 결과 19,898자, 입력 65,628, $0.1969, 4턴, 24.4초
  run-3.jsonl: O, ToolSearch ctx_execute ctx_execute, 결과 19,692자, 입력 65,528, $0.1405, 4턴, 21.8초
  중앙값: 결과 19,692자, 입력 65,628, $0.1405, 4턴, 23.1초

hooks는 3번 모두 ctx_*를 부르지 않았어요. Claude가 처음부터 python -m pytest -q 2>&1 | tail -40처럼 Bash에서 스스로 걸러 읽어서 줄일 큰 출력이 없었습니다.

그래도 hook이 세션 시작에 넣는 안내문(4,603자)과 첫 Bash 앞에 넣는 안내(679자), 늘어난 도구 목록 때문에 입력 토큰 중앙값은 38,349에서 50,435로 1.3배가 됐어요. 늘어난 몫이 대부분 캐시 읽기라 비용 추정 중앙값은 $0.0731 대 $0.0704로 비슷했습니다.

guide는 3번 모두 ctx_execute를 썼지만 명령 안에서 이미 grep, head로 걸렀어요. 입력 토큰 중앙값 65,628로 세 조건 중 가장 컸는데, 결과가 3,414자뿐인 1회차도 71,484였으니 큰 몫은 공식 지침과 도구 목록이 턴마다 다시 실리는 고정 비용과 ToolSearch 한 턴입니다.

정리

범위: Claude Code 2.1.309 claude -p, Opus 5.5, effort medium, tool search 켬, Docker로 붙인 context-mode 1.0.169, 실패 테스트 2개인 Python 프로젝트, 준비 3번 + 명령 고정 과제 18번 + 자유 과제 9번 호출.

서버 도구만 따로 보면 ctx_batch_execute가 137,851바이트 pytest 출력을 5,936바이트로 줄이고 답이 든 줄을 남겼어요. ctx_execute는 intent가 없으면 100KB 미만 출력을 줄이지 않았고 intent를 주면 실패한 테스트가 빠졌으니, 어떤 도구로 부르는지 확인하세요.
큰 출력이 나오는 명령을 지정하자 Claude는 먼저 Bash로 실행해 잘린 10,040자를 받았고, hooks는 그 뒤에 ctx_batch_execute로 다시 실행했어요. 입력 토큰 중앙값은 base 71,416, hooks 72,593으로 줄지 않았고, 비용 추정 중앙값은 hooks가 2.2배였어요. 캐시 효과를 빼도 약 1.4배, 캐시가 빈 준비 호출끼리는 1.8배였습니다.
명령을 맡기면 Opus는 tail, grep으로 스스로 출력을 걸렀고, hooks는 ctx_*를 한 번도 쓰지 않은 채 입력이 1.3배가 됐어요(비용 추정 중앙값은 $0.0731 대 $0.0704로 비슷).
공식 지침을 둔 guide는 ctx_*를 자유 과제 3번 모두 골랐지만 이미 거른 명령을 감쌌을 뿐이고, 지침이 더한 고정 비용으로 입력 토큰 중앙값이 65,628로 가장 컸어요.
정답은 hooks 6/6, base 5/6이었어요. base의 1번은 "명령을 바꾸지 말라"는 지시 때문에 잘린 출력만 보고 틀렸고, hooks는 같은 명령을 다시 실행해 답을 찾았어요. 이 질문에서 6번 중 1번 차이였습니다.