GLM-5.2 실전 테스트: GPT-5.5 앞지른 오픈소스 코딩 모델, 1/6 가격에 Claude Code까지 붙는다

타이밍이 묘했습니다. 미국 정부가 Anthropic의 최신 모델에 대한 해외 접근을 제한한 바로 다음 날, Z.ai가 GLM-5.2를 MIT 라이선스로 공개했습니다. SWE-bench Pro 62.1%로 GPT-5.5(58.6%)를 앞지르고, 출력 비용은 GPT-5.5의 1/6입니다. Claude Code에는 환경변수 세 줄로 붙습니다.

---

핵심 요약

GLM-5.2는 Z.ai(구 Zhipu AI)가 2026년 6월 13일 유료 Coding Plan 구독자에게 먼저 공개하고, 6월 16~17일 MIT 라이선스 오픈웨이트를 HuggingFace에 올린 플래그십 모델입니다. 744B MoE 구조에 40B 파라미터만 추론 시 활성화되고, 컨텍스트 창은 GLM-5.1의 200K에서 1M으로 5배 뛰었습니다.

벤치마크 숫자가 화제가 된 이유는 단순히 오픈소스치고 잘 나왔기 때문이 아닙니다. SWE-bench Pro 62.1%로 GPT-5.5(58.6%)를 3.5포인트 앞섰고, Terminal-Bench 2.1에서 81.0%를 찍어 오픈웨이트 모델 중 처음으로 80%를 넘었습니다. FrontierSWE 장시간 코딩 작업에서는 74.4%로 GPT-5.5(72.6%)를 앞서고 Claude Opus 4.8(75.1%)과 1포인트 차이 안으로 들어왔습니다. Z.ai가 런치 당일에 벤치마크를 하나도 공개하지 않고 "먼저 써봐라" 전략을 쓴 게 오히려 커뮤니티 신뢰를 높였습니다. 숫자는 Artificial Analysis와 VentureBeat가 독립적으로 측정했습니다.

가격이 결정적입니다. Z.ai API 기준 입력 $1.40/1M, 출력 $4.40/1M으로, GPT-5.5 출력($30/1M)의 약 1/6입니다. Claude Opus 4.8($25/1M)과 비교해도 5분의 1 수준입니다. GLM Coding Plan 구독($30/월 Pro)을 쓰면 사용량 범위 안에서 더 저렴합니다.

구조적 차별점은 IndexShare입니다. 스파스 어텐션의 top-k 인덱스를 레이어 그룹 사이에서 재사용하는 방식으로, 1M 토큰 컨텍스트에서 FLOPs를 기존 대비 2.9배 줄였습니다. 추론 강도는 High와 Max 두 단계로 나뉘는데, 복잡한 에이전트 태스크에는 Max, 단순 코드 생성에는 High가 적당합니다.

주의할 점도 있습니다. 로컬 실행은 FP8 기준 약 860GB VRAM이 필요해서 일반 개발자 환경에서는 불가능합니다. Unsloth 2비트 양자화로 압축하면 256GB 통합메모리 맥에서 돌아가지만 품질 손실이 있습니다. 비전 입력이 없어서 이미지·영상 처리는 안 되고, 출력 토큰당 비용이 DeepSeek V4 Pro($0.87/1M)보다는 높습니다.

---

실전 1: API 연동 기본 세팅

GLM-5.2는 Anthropic Messages API와 호환되는 엔드포인트를 제공합니다. 기존 Claude 코드에서 ANTHROPIC_BASE_URL과 ANTHROPIC_API_KEY만 바꾸면 됩니다. GLM Coding Plan 키는 open.z.ai에서 발급받습니다.

OpenAI 호환 방식도 지원하므로 기존 코드 스타일에 맞게 선택하면 됩니다.

# 방법 1: Anthropic SDK (Claude 코드 마이그레이션용)
import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("GLM_API_KEY"),
    base_url="https://open.z.ai/api/paas/v4/"
)

response = client.messages.create(
    model="glm-5.2[1m]",  # [1m] 붙여야 1M 컨텍스트 활성화
    max_tokens=4096,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,
        "effort": "max"  # "high" 또는 "max"
    },
    messages=[
        {"role": "user", "content": "Python으로 LRU 캐시를 처음부터 구현해줘. thread-safe 버전 포함."}
    ]
)

print(response.content[0].text)
print(f"입력: {response.usage.input_tokens}, 출력: {response.usage.output_tokens}")
# 비용: 입력 * 0.00000140 + 출력 * 0.00000440 (달러)

# 방법 2: OpenAI SDK
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("GLM_API_KEY"),
    base_url="https://open.z.ai/api/paas/v4/"
)

response = client.chat.completions.create(
    model="glm-5.2[1m]",
    messages=[
        {"role": "user", "content": "FastAPI + SQLAlchemy 비동기 CRUD 보일러플레이트 만들어줘"}
    ],
    max_tokens=4096,
    extra_body={"thinking": {"effort": "high"}}
)

print(response.choices[0].message.content)

모델 ID에 [1m]을 붙이는 게 핵심입니다. 빼면 기본 컨텍스트 길이로 돌아가고, 대형 코드베이스 작업에서 컨텍스트가 잘립니다.

---

실전 2: Claude Code에 GLM-5.2 붙이기

GLM-5.2의 가장 실용적인 활용 중 하나가 Claude Code 백엔드 교체입니다. Anthropic 호환 엔드포인트 덕분에 환경변수 세 줄이면 끝입니다. API 비용을 Claude Opus 대비 최대 80% 줄이면서 Claude Code의 파일 조작, 터미널 실행, Plan Mode를 그대로 씁니다.

# .bashrc 또는 .zshrc에 추가
export ANTHROPIC_BASE_URL="https://open.z.ai/api/paas/v4/"
export ANTHROPIC_API_KEY="your-glm-coding-plan-key"
export ANTHROPIC_DEFAULT_SONNET_MODEL="glm-5.2[1m]"
export ANTHROPIC_DEFAULT_OPUS_MODEL="glm-5.2[1m]"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="glm-5.2[1m]"  # 단순 태스크도 동일 모델
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1000000  # 1M 컨텍스트 활용

# 적용 후 Claude Code 실행
source ~/.zshrc
claude

# 현재 연결된 모델 확인
/model  # GLM-5.2 표시되면 정상

CLAUDE_CODE_AUTO_COMPACT_WINDOW=1000000 설정이 중요합니다. 이게 없으면 Claude Code가 기본값인 200K 근처에서 컨텍스트를 자동으로 압축해버려서 1M의 이점을 못 씁니다. 대형 레포지토리 작업 시 반드시 챙겨야 합니다.

전환 후 실제로 사용해보면 Plan Mode, /init, 파일 편집, 터미널 실행이 Claude 백엔드를 쓸 때와 동일하게 동작합니다. 복잡한 멀티파일 리팩토링에서 Claude Opus 4.8 수준은 아니지만, 일상적인 기능 구현이나 디버깅은 차이가 체감하기 어렵습니다.

---

실전 3: 코딩 성능 벤치마크 직접 측정

공개 벤치마크는 참고용이고, 내 워크로드에서 직접 측정하는 게 맞습니다. 아래는 GLM-5.2와 GPT-5.5를 같은 코딩 태스크에 보내고 품질과 비용을 비교하는 스크립트입니다.

import time
from openai import OpenAI
import os

# GLM-5.2
glm_client = OpenAI(
    api_key=os.getenv("GLM_API_KEY"),
    base_url="https://open.z.ai/api/paas/v4/"
)

# GPT-5.5
gpt_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def benchmark_coding(prompt: str, task_name: str):
    models = [
        (glm_client, "glm-5.2[1m]", "GLM-5.2", 1.40, 4.40),
        (gpt_client, "gpt-5.5", "GPT-5.5", 5.00, 30.00),
    ]
    
    print(f"\n{'='*60}")
    print(f"태스크: {task_name}")
    
    for client, model_id, label, in_price, out_price in models:
        start = time.time()
        resp = client.chat.completions.create(
            model=model_id,
            messages=[{"role": "user", "content": prompt}],
            max_tokens=2048,
            temperature=0.2
        )
        elapsed = time.time() - start
        
        out = resp.choices[0].message.content
        in_tok = resp.usage.prompt_tokens
        out_tok = resp.usage.completion_tokens
        cost = (in_tok * in_price + out_tok * out_price) / 1_000_000
        
        print(f"\n[{label}] {elapsed:.1f}s | 입력 {in_tok} / 출력 {out_tok} | ${cost:.5f}")
        print(out[:500])

# 실제 코딩 태스크로 테스트
tasks = [
    (
        "Python으로 비동기 작업 큐를 구현해줘. 우선순위 지원, 재시도 로직(지수 백오프), "
        "데드레터 큐까지 포함. asyncio 기반.",
        "비동기 작업 큐"
    ),
    (
        "다음 코드의 메모리 누수와 성능 병목을 찾아줘:\n"
        "def process_files(directory):\n"
        "    results = []\n"
        "    for f in os.listdir(directory):\n"
        "        with open(f) as file:\n"
        "            data = json.load(file)\n"
        "            results.append(data)\n"
        "    return results",
        "코드 리뷰"
    ),
    (
        "LangGraph 멀티에이전트 시스템을 설계해줘. "
        "리서치 에이전트, 코드 작성 에이전트, 리뷰 에이전트 세 개가 Supervisor 패턴으로 협업.",
        "멀티에이전트 설계"
    )
]

for prompt, name in tasks:
    benchmark_coding(prompt, name)

직접 돌려보면 단순 코드 생성에서는 GLM-5.2가 GPT-5.5와 거의 차이가 없고, 장시간 다단계 에이전트 태스크에서 오히려 GLM-5.2가 앞서는 케이스가 나옵니다. Terminal-Bench 81%가 단순한 숫자가 아니라 실제로 터미널 에이전트 작업에서 강하다는 뜻입니다.

---

실전 4: 1M 컨텍스트 — 전체 레포 분석

GLM-5.1에서 가장 불편했던 점이 200K 컨텍스트 제한이었습니다. 중간 규모 레포지토리도 컨텍스트가 잘려서 작업 도중 앞부분 맥락을 잃는 일이 잦았습니다. 1M으로 늘어나면서 이 문제가 실질적으로 해소됐습니다.

공식 스트레스 테스트에서 웹·모바일·미니프로그램 일괄 납품 작업에 약 88만 토큰을 한 세션에서 처리했다고 Z.ai가 밝혔습니다. 아래는 대형 코드베이스를 통째로 넣고 분석하는 실전 패턴입니다.

from pathlib import Path
import anthropic

client = anthropic.Anthropic(
    api_key=os.getenv("GLM_API_KEY"),
    base_url="https://open.z.ai/api/paas/v4/"
)

def load_repo(path: str, max_chars: int = 3_000_000) -> str:
    """레포지토리 전체를 로드 (약 750K 토큰 = 3M 문자)"""
    exts = {".py", ".ts", ".js", ".go", ".java", ".rs", ".tsx", ".jsx"}
    skip = {"node_modules", ".git", "__pycache__", "dist", "build", ".next"}
    
    parts = []
    total = 0
    for file in sorted(Path(path).rglob("*")):
        if any(s in file.parts for s in skip):
            continue
        if file.suffix not in exts:
            continue
        try:
            text = file.read_text(encoding="utf-8", errors="ignore")
            entry = f"\n### {file.relative_to(path)} ###\n{text}\n"
            if total + len(entry) > max_chars:
                break
            parts.append(entry)
            total += len(entry)
        except Exception:
            continue
    
    print(f"로드 완료: {total:,}자 ({total//4:,}토큰 추정)")
    return "".join(parts)

# 레포 통째로 로드
repo = load_repo("./my-project")

# GLM-5.2로 전체 코드베이스 분석
response = client.messages.create(
    model="glm-5.2[1m]",
    max_tokens=8192,
    thinking={"type": "enabled", "budget_tokens": 20000, "effort": "max"},
    messages=[
        {
            "role": "user",
            "content": f"다음 코드베이스 전체를 분석해줘:\n\n{repo}\n\n"
                      "분석 항목:\n"
                      "1. 아키텍처 패턴과 레이어 구조\n"
                      "2. 잠재적 보안 취약점\n"
                      "3. 성능 병목 지점\n"
                      "4. 리팩토링 우선순위 TOP 5"
        }
    ]
)

print(response.content[-1].text)

1M 컨텍스트가 실제로 "쓸 수 있는" 수준이라는 Z.ai의 주장은 IndexShare 덕분입니다. 일반적인 어텐션은 컨텍스트가 길어질수록 FLOPs가 제곱으로 증가하는데, IndexShare로 top-k 인덱스를 레이어 그룹 간에 재사용해서 1M에서의 계산량을 2.9배 줄였습니다.

---

실전 5: 로컬 실행 — 현실적인 선택지

GLM-5.2 전체 모델은 FP8 기준 약 860GB VRAM이 필요합니다. H100 8장이 있어야 간신히 돌아간다는 얘기라서 일반 개발자에게는 현실적이지 않습니다. 그러나 Unsloth가 공개한 동적 GGUF 양자화 파일을 쓰면 다른 경로가 열립니다.

Unsloth 2비트 동적 양자화는 BF16 대비 약 82% 정확도를 유지하면서 파일 크기를 84% 줄입니다. Apple M3 Max 128GB 맥에서 약 26토큰/초가 나온다는 커뮤니티 측정도 있습니다.

# Unsloth GGUF 다운로드 (2비트 동적 양자화, 약 240GB)
pip install huggingface_hub

# 모델 다운로드 (시간 많이 걸림 — resume 필수)
huggingface-cli download \
  unsloth/GLM-5.2-GGUF \
  --include "GLM-5.2-IQ2_M.gguf" \
  --local-dir ./models/glm-5.2 \
  --resume-download

# llama.cpp로 서버 실행 (128GB+ 통합메모리 맥)
./llama-server \
  -m ./models/glm-5.2/GLM-5.2-IQ2_M.gguf \
  --n-gpu-layers 999 \
  --ctx-size 131072 \
  --host 0.0.0.0 \
  --port 8080

# OpenAI 호환 서버가 localhost:8080에 뜸
curl http://localhost:8080/v1/models

256GB 이상 통합메모리가 있는 M4 Max Ultra나 M3 Ultra 맥이라면 3비트나 4비트 양자화로 올리면 품질이 더 낫습니다. 자체 호스팅의 실익은 비용보다는 코드를 외부 서버로 보내지 않는다는 데 있고, $600 이상의 API 비용이 나오는 팀이라면 자체 H100 클러스터가 경제적으로 역전되는 시점이 됩니다.

---

마무리

GLM-5.2는 "오픈소스치고 잘 나온 모델"이 아니라 코딩 벤치마크에서 GPT-5.5를 처음으로 앞지른 오픈웨이트 모델입니다. MIT 라이선스에 GPT-5.5의 1/6 비용, Claude Code 환경변수 세 줄 연동, 1M 실용 컨텍스트까지 묶어서 나온 타이밍이 묘합니다. 비전 입력이 없고 전체 로컬 실행이 현실적이지 않다는 한계는 있지만, API로 쓰는 코딩 에이전트 워크플로우에서는 지금 당장 GPT-5.5 대신 테스트해볼 이유가 충분합니다. 특히 Claude Code 비용이 부담스러웠던 팀에게 가장 직접적인 대안입니다.

---