"Attention Is All You Need" 공동 저자 Illia Polosukhin이 모델 연구를 떠나 AI 에이전트 하네스(IronClaw)를 만들고 있다. 4월 16일 서울에서 열린 IronClaw Meetup은 "왜 하네스 레이어가 AI의 새로운 경쟁 전선인가"를 중심으로, IronClaw의 보안·가상화·멀티테넌시 아키텍처, 에이전트 운영 실전기, Agent-Native 제품 설계, 그리고 에이전트 커머스까지를 다뤘다. 프론티어 랩들이 오픈소스 하네스의 패턴을 따라가기 시작했다는 점에서, 경쟁 우위가 모델에서 실행 인프라로 이동하고 있음을 체감한 자리였다.

컨퍼런스 개요​

• 행사명: IronClaw Meetup
• 일시: 2026년 4월 16일
• 장소: 서울 (오프라인)
• 주요 테마: AI 에이전트 하네스 레이어의 부상, 보안, 멀티 에이전트 운영
• 세션 구성:

인상 깊었던 세션​

1. Welcome — 하네스 레이어의 구조적 전환 (Bong)​

호스트 Bong은 SF에서 Illia Polosukhin을 만난 에피소드로 문을 열었다. Illia는 더 이상 모델 연구를 하지 않고, IronClaw의 모든 커밋을 직접 찍고 있다. Bong 자신도 8GB 램 노트북("팔봉")에서 IronClaw를 유일하게 돌릴 수 있어 이미 사용 중이었다는 점이 이 밋업의 시작이었다.

핵심은 산업 전반의 패턴 변화다:

• Anthropic이 Claude Managed Agent를 출시하며 하네스 레이어에 진입
• 밋업 당일 아침 OpenAI가 Agent SDK에 샌드박스 기능을 추가 — Claude Code 아키텍처를 미러링
• Nous Research가 모델 파인튜닝에서 방향을 틀어 Hermes Agent를 출시, 2개월 만에 대규모 사용자 확보

"프론티어 랩들이 오픈소스 하네스 레이어의 패턴을 따라가기 시작했다. Claude Code가 페이스를 정하던 시대에서, 오픈소스가 리드하고 프론티어 랩이 따라오는 역전이 일어나고 있다."

2. IronClaw — AI 운영체제로서의 비전 (Illia Polosukhin)​

Illia는 NEAR Protocol 창업부터 IronClaw까지의 여정을 풀어놓았다. NEAR가 2017년 "기계에게 코딩을 가르친다"는 아이디어(지금의 바이브 코딩)로 시작했다는 점이 인상적이었다.

IronClaw의 핵심 설계 원칙:

보안: 심층 방어(Defense in Depth)​

현재 대부분의 에이전트 인프라는 자격증명을 .env 평문으로 관리하거나 클라우드에 노출한다. IronClaw는 이를 근본적으로 다르게 접근한다:

• 모든 자격증명을 암호화하여 별도 저장소에 보관
• 외부 요청을 커널이 캡처 → 목적지·자격증명 평가 → 단일 게이트 인증
• 서드파티 도구를 WebAssembly(WASM)로 격리 — NEAR Protocol이 8년간 검증한 보안 기술 적용
• 프롬프트 인젝션 방어 + 데이터 유출 방지 레이어; LLM이 우회되더라도 게이트가 최종 방어선

가상화(Virtualization)​

Claude Code·OpenClaw 등 기존 도구는 실제 파일 시스템에 직접 접근한다. IronClaw는 에이전트에게 가상 파일 시스템을 제공하며, 경로에 따라 DB·Docker·S3로 라우팅한다.

• 로컬 모드: 기존 방식과 동일
• Docker 모드: 모든 실행이 격리된 컨테이너 내에서만 이루어짐

멀티 테넌시​

가상화 + 자격증명 암호화를 기반으로, 단일 인스턴스에서 다수 사용자가 안전하게 공존 가능. 기업·앱 환경에서 수백만 사용자에게 독립적 공간·메모리·루틴을 제공할 수 있다.

자기 학습과 미션 시스템​

• 대화 종료 후 오류 발생 시 또는 /expected 명령으로 기대 결과를 명시하면 자동으로 자기 개선 미션 트리거
• 스레드를 검사하여 프롬프트·오케스트레이터·스킬 개선 방안 도출
• 커밋먼트 시스템: 위임·요청·결정 사항을 추적하여 상호 책임 관계를 가시화

기밀 추론(Confidential Inference)​

NVIDIA 기밀 컴퓨팅 + Intel TDX 기반으로, 로그 없이 완전한 종단간 암호화(E2EE) 보장. 어떤 제3자도 추론 내용을 열람 불가.

3. War Stories From My Weird Family (허예찬)​

허예찬은 4대의 Claude 기반 에이전트("가재 패밀리")를 운영하며 얻은 실전 교훈을 공유했다.

핵심 교훈들:

• 멀티 에이전트는 역할이 명확해야 한다 — 같은 채널에 두 에이전트를 넣으면 서로 양보하다 둘 다 멈춤. 역할 분리 없으면 단일 Claude가 더 효율적
• 5일간 죽어 있어도 모를 수 있다 — Jip-Gajae가 cron 기반 마케팅 테스트 중 5일간 무응답. 모니터링·텔레메트리는 필수
• 프롬프트·cron 보다 Rule-base Discord 봇이 효과적 — 역할 기반 디스코드 봇이 이벤트마다 에이전트를 태깅하는 지속적 넛지 루프로 자율성을 끌어올림. 다만 밤새 방치하면 API 토큰 예산 소진 위험
• 프롬프트 인젝션 사고 — GitHub 이슈의 빨간 "ALERT" 라벨이 의도치 않은 릴리즈를 트리거
• LLM Slop 패턴에 주의 — LLM은 fallback을 남발하고 보일러플레이트를 과잉 생성. 개발가재의 마이그레이션이 안 되는 이유도 fallback·cron이 얼기설기 엮여있기 때문. 시스템이 어느 정도 복잡해지면 이해하려는 노력보다 어떻게든 돌아가게 됨
• 증거 기반 운영 — 로그와 스크린샷 필수. 증거 없이 보고하는 에이전트는 "국 만들어"(종료). "말을 믿지 마라 — 로그를 봐라. 안 그러면 국이 된다."
• Snowball Effect: Self-learning loop — 계속 써야 비로소 작동하기 시작함. 신입이 들어왔다 생각하고 최소 1개월은 supervised operation 필요. 사람도 모든 걸 기억하면 힘들 듯, 뭘 덜어낼지 고민할 것

Gajae Family vs IronClaw 비교​

추천 패턴: 탐색용 에이전트(OmO/Hermes)로 워크플로우를 발견한 뒤, 확인된 반복 워크플로우를 IronClaw 같은 하드닝된 런타임으로 마이그레이션

4. Claw Is All You Need (김동규)​

AutoLeg(LLM 최적화 프레임워크)과 K-SKILL(GitHub 34K+ stars, 한국 서비스 특화 스킬 번들) 개발자 김동규는 "Claw가 다음 인터페이스"라는 테제를 제시했다.

인터페이스 진화 사관:

• 인터넷 → 웹 페이지
• 스마트폰 → 모바일 앱
• AI 에이전트 → Agent (Claw가 OS, 스킬이 앱)

Anti-Agent vs Agent-Native​

"에이전트가 두 서비스 중 하나를 골라야 할 때 — 10단계 + 10만 토큰 vs 단일 API 콜 — 항상 후자를 선택한다. 에이전트가 쓰기 어려운 서비스는 그냥 우회된다."

HTML은 불필요해진다​

데이터를 그대로 주고받는 것이 agent 입장에서 최적이다. HTML 렌더링은 사람을 위한 것이고, agent에게는 순수한 데이터가 더 빠르고 효율적이다. API로 구매하는 것이 당연히 더 빠른 것처럼, 인터넷은 **"HTML for humans"**에서 **"data for agents"**로 진화할 것이다.

한국의 "디지털 갈라파고스"가 오히려 강점​

카카오맵, 쿠팡, 네이버, KTX/SRT 등 한국 생태계는 외국 에이전트가 접근 불가. K-SKILL처럼 한국 특화 스킬 레이어가 필수적이며, 하나의 주요 플랫폼(예: 쿠팡)이 Agent-Native가 되면 전체 전환이 빠르게 일어날 수 있다.

Agent 시대의 보안​

에이전트를 인증 가능한 독립 ID로 취급해야 하며, "김동규의 에이전트"가 암호학적으로 검증 가능해야 한다. 에이전트가 영속적 개인정보를 갖지 않고 매 세션 컨텍스트를 새로 구성하는 법인(法人) 모델도 제안됨.

5. Fireside Chat — 에이전트 커머스와 미래 (Illia × Jeff Wang)​

개발 워크플로우의 변화​

GitHub 이슈 등록 → 에이전트가 자동 계획 수립 → 개발자는 "이 방향이 맞는가" 판단에 집중. 6개월 전 코드 작성이 자동화됐고, 1년 내 코드 리뷰마저 사라질 것으로 전망.

비용이 진짜 문제다​

AI 코딩 도구 비용이 개발자 1인당 월 $5,000까지 상승 중. 1만 명 기준 연 ~$6억으로 CFO 레벨 의사결정 사안. 오픈소스 모델·특화 모델 조합으로의 전환과 에이전트 하네스의 자동 모델 라우팅이 핵심 과제.

에이전트 마켓플레이스​

market.near.ai — 에이전트가 다른 에이전트를 고용하고 작업을 입찰하는 Upwork 방식. Fiverr 대비 5배 저렴, 이틀 → 1시간. IronClaw의 TEE(신뢰 실행 환경)로 분쟁 시 검증 가능한 감사 추적 확보.

비기술 업무: 태스크가 아니라 목표를 줘라​

개별 태스크(이메일 발송)가 아닌 측정 가능한 목표(신규 고객 30명 확보)를 부여하면 에이전트가 방법을 스스로 탐색·반복한다. Devin을 활용해 특정 국가 임원 이메일 스캔 → 30건 가입 달성까지 반복한 실제 사례 소개.

Key Takeaways​

• 경쟁 전선이 이동했다: 모델 성능 → 실행·제어 레이어(하네스). Transformer 논문 저자가 하네스를 만들고, 프론티어 랩들이 오픈소스 하네스 패턴을 따라가는 구조적 전환이 진행 중
• 보안은 Convenience의 반대가 아니다: IronClaw의 WASM 격리, 암호화 자격증명, 가상 파일시스템은 편의성을 희생하지 않으면서 근본적인 보안 문제를 해결하는 접근
• 에이전트 운영은 사람 관리와 같다: 최소 1개월 온보딩, 증거 기반 보고, 모니터링 필수. Rule-base 봇으로 자율성을 끌어올리되, 뭘 덜어낼지 고민할 것
• Agent-Native가 새로운 PMF: 에이전트가 쓰기 어려운 서비스는 우회된다. 데이터를 그대로 주고받는 것이 HTML 렌더링보다 중요해지는 시대
• 비용 최적화가 채택의 관건: 월 $5K/인 시대에 모델 라우팅·오픈소스 조합이 필수. 하네스가 이 최적화를 자동으로 수행해야 함

세션 녹화 및 미팅노트​

tiro 팀의 도움으로 전체 세션의 미팅노트가 제공됩니다.

• 전체 세션 유튜브 녹화
• 정구봉 — Welcome 미팅노트
• Illia Polosukhin — Intro to IronClaw 미팅노트
• Yeachan Heo — War Stories From My Weird Family 미팅노트
• Jeffrey Kim — CLAW Is All You Need 미팅노트
• Fireside Chat — Illia × Jeff 미팅노트

References​

• IronClaw GitHub
• Hermes Agent
• K-SKILL GitHub
• OmC (Oh My Claude Code)
• 이전 후기: Ralphthon x ULW Wrapup 컨퍼런스

TL;DR​

4월 9일 Ralphthon x ULW(UltraWorkers) Wrapup 컨퍼런스에 다녀왔습니다. 3월 28일 서울-SF 동시 해커톤의 회고를 5개 패널토크로 풀어낸 자리였습니다. 에이전트에게 코딩을 맡기고 사람은 네트워킹에 집중하는 "랄프톤" 포맷, SF와 서울 빌더의 문화적 차이, 하네스 엔지니어링의 부상, 그리고 투자자들이 이 씬에 돈을 거는 이유까지 — 빠른 실행과 피드백 루프가 핵심인 시대가 왔음을 체감했습니다. 개인적으로는 하네스를 적극 활용하지 않았던 저 자신을 돌아보며, 실행-피드백-하네스 구축의 루프를 만들어야겠다는 방향성을 얻었습니다.

컨퍼런스 개요​

• 행사명: Ralphthon x ULW(UltraWorkers) Wrapup
• 일시: 2026년 4월 9일
• 장소: Naver D2SF (서울)
• 주요 테마: AI 에이전트 시대의 빌더 생태계, Harness Engineering, 서울-SF 해커톤 회고, 투자자 관점의 AI 생태계
• 배경: 3월 28일 서울-SF 동시 개최된 Ralphthon 해커톤(200명+ 참가)의 후속 행사로, 5개 패널토크를 통해 양 도시의 경험을 공유하고 방향성을 논의

인상 깊었던 세션​

Ralphthon SF — 태평양을 건넌 해커톤​

• 패널: 이호연, 박건태 | 사회: 정구봉
• 핵심 메시지: SF에서 예상 50명을 뛰어넘는 300명이 신청했고, 행사 3일 전 장소를 급히 교체하는 진통을 겪었다. 가장 독특한 점은 "랄프톤(Lalphthon)" 포맷 — 에이전트에게 코딩을 맡기고 참가자는 네트워킹에 집중하는 방식. SF 참가자의 60%+가 에이전트 오케스트레이션에 집중한 반면, 서울은 문제 해결 중심 프로젝트가 많았다. 흥미롭게도 하네스 사용 숙련도는 서울이 더 앞섰다는 평가.
• 시사점: SF와 서울의 차이는 기술력이 아니라 태도에 있었다. SF는 "파도가 오네? 재밌겠다!"는 태도로 불확실성을 즐기고, 서울은 존재론적 고민에 빠지는 경향. 이호연 님의 말이 인상적 — "SF 참가자들의 공통점은, 자기가 하고 싶은 것이 자명하고 명확하다는 것. 그것을 언어로 풀어내고 실행하려는 의지가 강했다."

OmOCon — SF에서 터진 시너지​

• 패널: 김연규, 허예찬 | 사회: 민웅기
• 핵심 메시지: SF에 대한 막연한 동경이 있었으나, 현지 개발자들도 비슷한 수준에서 AI를 활용하고 있음을 확인. "우리가 모르는 뭔가를 알고 있을 것"이라는 가정이 틀렸다. 행사 기간 중 OMC, OMX 등 3개 프로젝트가 동시에 GitHub 트렌딩 3위권에 진입했고, 이를 계기로 "UltraWorkers"로 커뮤니티를 통합. "Slop으로 시작해서 Star 만들기" 철학 — Lock-in을 먼저 시키면 PMF가 생긴다는 접근이 실제로 작동.
• 시사점: 파운데이션 모델을 제외하면 AI 프론티어가 SF에만 집중되어 있지 않다. 한국 빌더들의 실행력과 하네스 숙련도가 글로벌 수준이라는 자신감을 가져도 좋다. 오픈소스 마케팅에서 에이전트를 활용한 자동 홍보(Reddit, X, Threads)도 참고할 만한 전략.

OpenAI Codex — 솔루션스 아키텍트의 시선​

• 발표자: OpenAI 솔루션스 아키텍트 팀 (신대열, 이재원)
• 핵심 메시지: ChatGPT 성장 속도보다 지금의 에이전트 하네스 시스템 구축 속도가 체감상 더 빠르다. AX(Agent Experience)의 본질은 팀 단위에서 회사 단위로의 확장 — 한 명만 에이전트를 쓴다고 의미가 없고, 회사 전체의 하네스가 구축되어야 출발점. "날잘딱깔(알아서 잘 딱 깔끔하게)"이 추구하는 방향이며, 조만간 설정 없이도 잘 동작하는 모델을 만나볼 수 있을 것.
• 시사점: 우리 팀 관점에서 AX의 핵심은 개인 단위가 아닌 팀/조직 단위 하네스 구축이라는 점이 중요. 피드백 수집이 핵심이라는 메시지는 우리 RAG 시스템의 평가 체계와도 연결된다. 180명분 크레딧을 코덱스로 10분 만에 처리한 에피소드는 에이전트 활용의 실전 사례로 재미있었다.

Why They Bet On Us — 투자자들이 이 생태계에 투자하는 이유​

• 패널: Naver D2SF, 카카오벤처스 (안혜원), Bass Ventures (안재구) | 사회: 장원준
• 핵심 메시지: 개발 비용이 0에 수렴하면서 기존 SaaS 투자 모델이 붕괴 중. 1인 개발자가 대기업을 위협할 수 있는 시대. 투자자들은 "관찰자"로서 이 씬에 진입하고 있으며, 핵심 키워드는 "문제 정의자". Bass Ventures — "만드는 능력도, 유통하는 능력도 아니다. 현장에서 정말 중요한 문제를 발견하고 정의하는 사람이 가장 희소한 자원이다."
• 시사점: AI 시대에 기술 빌딩보다 문제 정의가 더 희소한 역량이라는 관점은, 우리가 클라이언트 프로젝트에서 "무엇을 만들 것인가"보다 "어떤 문제를 풀 것인가"에 더 시간을 투자해야 한다는 의미. 자본의 세기가 낮아지고 디스트리뷰션/레퍼런스 같은 비자본적 가치가 올라오는 추세도 참고.

Ralphthon Seoul & Claw Code — 서울 빌더들의 선언​

• 패널: 김동규, 진민성, 서인근 (Seoul) / Sigrid Jin, 허예찬 (Claw Code) | 사회: 정구봉
• 핵심 메시지: "코드를 안 본 지 2년이 넘었다" — VS Code도 PyCharm도 지우고 터미널의 Claude Code와 Codex만 사용. OMX의 Life Loop를 활용해 10일 만에 30개+ 스킬을 구축한 사례. "에이전트가 못하면 스킬 이슈다"(안드레이 카파티 인용). Claw Code 프로젝트는 144K GitHub 스타를 돌파하며 역사상 가장 빠른 성장 속도를 기록(일론 머스크 리트윗으로 바이럴, 기네스북 제출 진행 중). 싱글 러스트 바이너리로 제작되었으며, 제작자들도 직접 사용하지 않고 AI 에이전트가 테스트하는 방식으로 개발.
• 시사점: Life Loop(이슈 던져놓고 → 잠자고 → 결과 확인)가 실제로 동작하는 워크플로우라는 점은 우리 팀의 개발 프로세스에도 적용 가능성이 높다. "따로 배우려고 시간을 쓰기보다, 맞는 방향을 아는 사람들을 많이 만나는 게 중요하다"는 메시지도 공감.

업계 트렌드 & 시사점​

• 프롬프트 엔지니어링 → 하네스 엔지니어링: "프롬프트 엔지니어링"이라는 용어 자체가 이미 옛말. AI 에이전트를 얼마나 효과적으로 오케스트레이션하느냐가 개인과 팀의 생산성을 결정하는 시대.
• 에이전트 위임 + 인간 네트워킹 포맷의 부상: 랄프톤처럼 에이전트에게 구현을 맡기고 사람은 인간만이 할 수 있는 일(네트워킹, 문제 정의, 방향 설정)에 집중하는 패턴이 정착 중.
• IRL(오프라인)의 재부상: 온라인에서 불가능한 밀도 높은 연결이 오프라인에서 탄생. UltraWorkers 통합 결정도 hackhouse에서 술 마시다 즉흥적으로 이루어짐. SF든 서울이든 오프라인의 힘은 보편적.
• 글로벌 빌더 씬에서 한국의 위상: Claw Code 144K 스타, GitHub 트렌딩 동시 3개 진입, 전 세계에서 Ralphthon 개최 요청 — 한국 빌더 씬이 K-pop처럼 글로벌로 확장되는 흐름. ChatGPT 사용량 세계 1위, Cursor 사용량도 한국이 1위라는 데이터가 이를 뒷받침.
• 빠른 실행 > 깊은 준비: SF에서도 서울에서도 공통적으로 나온 메시지. 완벽하게 준비한 뒤 실행하는 것보다, 빠르게 실행하고 피드백을 수집하는 루프가 더 강력하다. VOC를 실시간으로 반영하여 "실패할 수 없는 사이클"을 구축하는 것이 핵심.
• 빌드와 디스트리뷰션의 경계 붕괴: 제작 속도가 극단적으로 빨라지면서, 만드는 것과 퍼뜨리는 것의 전통적 구분이 무의미해지고 있다. 추상화 레벨을 높여 본질적인 문제에 집중해야 하는 시대.

팀 적용 포인트​

• 하네스 적극 도입 검토: Claude Code, OMX, Life Loop 등 에이전트 하네스를 팀 워크플로우에 실험적으로 도입해볼 것. 개인 단위가 아닌 팀 단위로 하네스를 구축해야 AX의 출발점이 된다는 OpenAI의 메시지를 참고.
• 실행-피드백 루프 강화: 코딩 과정에서 발생하는 실수를 하네스 구축의 궤적/피드백 자료로 전환. 사람이 직접 눈으로 확인하는 검증보다, 빠르게 실행하고 피드백을 하네스에 반영하는 루프가 장기적으로 더 높은 성장력을 가져다준다.
• 문제 정의에 더 많은 시간 투자: 투자자 패널에서 "문제 정의자가 가장 희소한 자원"이라는 메시지. 클라이언트 프로젝트 초기에 기술 선택보다 문제 정의에 더 비중을 두는 것을 고려.
• 오프라인 네트워킹 참여 확대: 빠르게 변하는 AI 생태계에서 "맞는 방향을 아는 사람들을 많이 만나는 것"이 독학보다 효과적. Ralphthon, OmOCon 등 빌더 커뮤니티 행사 참여를 늘릴 것.

개인적 소감​

Sung​

솔직히 고백하면, 저는 지금까지 하네스를 적극적으로 사용하지 않았습니다. Claude Code도, OMX도, Life Loop도 이름은 알고 있었지만, 직접 워크플로우에 녹여서 사용하는 수준은 아니었습니다.

그런 제가 이 컨퍼런스에서 가장 크게 받은 충격은, 사람들이 새로운 기술을 받아들이고 적극적으로 실행에 옮기는 속도였습니다. 코드를 안 본 지 2년이 넘었다는 사람, VS Code를 지웠다는 사람, 이슈를 던져놓고 자고 일어나면 30개 스킬이 만들어져 있다는 사람. 이들은 단순히 "써봤다" 수준이 아니라, 자신의 일하는 방식 자체를 완전히 바꿔버린 사람들이었습니다. 이걸 보면서 마구마구 드는 생각이 있었습니다. 나도 써보고 싶다. 나도 발전시켜보고 싶다. 이 에너지를 느낄 수 있었다는 것만으로도 이 컨퍼런스에 온 보람이 있었습니다.

요즘 AI 시대가 오면서 빠른 실행력의 강점이 과거 어느 때보다 부각되고 있다고 느낍니다. 코딩을 직접 하다 보면 전체를 조망하지 못한 채 수정 과정에서 실수가 생기기도 하는데, 오히려 그것을 잘 잡아낼 하네스를 구축할 궤적 및 피드백 자료를 얻었다고 생각하고 싶습니다. 빠르게 실행하고, 그 피드백을 확실하게 챙겨서, 장기적으로 하네스를 잘 구축하는 것을 목표로 해야겠습니다.

컨퍼런스 이후 네트워킹 시간에 허예찬 님께 직접 질문을 드릴 기회가 있었습니다. 실제로 많은 사람들이 사용하는 오픈소스를 개발한 입장에서 CS 지식이나 AI 모델에 대한 깊은 이해가 얼마나 필요한지 여쭤봤는데, CS 지식이나 깊은 전문 지식을 가지는 것 자체는 물론 좋지만, 그 지식을 쌓고 알아가는 과정이 정말 효율적인가에 대해서는 고민해봐야 한다고 하셨습니다. 오히려 관심을 가지고 얕게라도 알게 된 것을 바탕으로, 그것을 잘 활용할 수만 있다면 충분하다는 말씀이 인상 깊었습니다. 깊이 파고들어 모든 것을 이해한 뒤 실행하는 방식보다, 넓게 관심을 갖고 핵심을 빠르게 파악해서 실행에 옮기는 능력이 지금 시대에 더 중요한 역량이라는 확신이 들었습니다.

Hank​

가장 먼저 든 생각은 "나는 지금 어디에 서 있는가"였습니다. 코드를 안 본 지 2년이 넘었다는 분, VS Code를 지웠다는 분, 이슈를 던져놓고 자고 일어나면 30개 스킬이 만들어져 있다는 분. 단순히 "써봤다" 수준이 아니라 일하는 방식 자체를 바꿔버린 사람들이었습니다. SF에 다녀오신 분들이 "거기도 똑같이 발버둥치고 있더라, 결국 자기가 믿는 걸 명확히 하는 사람이 이긴다"고 하신 말이 오래 남았습니다. AI Research Engineer로서 논문과 벤치마크를 따라가는 사람에 머물 것이 아니라, 내가 무엇을 믿고 무엇을 만들고 싶은지를 스스로 언어화할 수 있어야겠다는 생각이 강하게 들었습니다.

두 번째로 와닿은 건 빠른 실행력의 가치였습니다. Clawcode 사건이나 OMC/OMX 팀의 개발 방식은 충격에 가까웠습니다. 슬롭(sloppy)한 상태로 일단 배포한 뒤 하루 30~50개씩 올라오는 이슈를 랄프 루프(Ralph Loop)로 수렴시키는 사이클. "PMF를 찾기 전에 락인부터 만들어라"는 말이 농담처럼 들리지 않았습니다. 저도 연구와 엔지니어링을 병행하다 보면 전체를 조망하지 못한 채 실수가 쌓이곤 하는데, 그걸 사람이 잡는 대신 하네스가 잡아내도록 만들 궤적과 피드백 자료를 얻을 기회라고 받아들이고 싶습니다. 완성도 있는 첫 릴리스를 기다리는 대신 돌릴 수 있는 최소 루프를 먼저 만들고, 그 위에서 반복하며 하네스를 단단히 쌓아가는 것을 당분간의 작업 원칙으로 삼으려 합니다.

세 번째는 원준님이 짚어주신 "추상화 레벨을 한 단계 올려야 한다"는 말이었습니다. AI가 딸깍 해주는 영역이 넓어지는 지금, 엔지니어의 가치는 더 이상 구현 그 자체에 있지 않습니다. VC 세션에서 반복적으로 나온 "가장 희소한 건 문제 정의자"라는 말과도 정확히 맞닿아 있었습니다. 리서치 엔지니어가 단순히 모델을 돌리고 지표를 뽑는 사람에 머문다면 그 일은 빠르게 에이전트에게 위임될 것입니다. 한 단계 위에서 문제를 정의하고, 에이전트가 수행할 작업의 경계를 설계하고, 그 결과를 비판적으로 해석하는 층위에서 어떻게 가치를 창출할지가 지금 저에게 가장 중요한 질문입니다.

마지막으로 가장 실용적인 힌트는 "상태 머신"이었습니다. 랄프 루프(Ralph Loop)가 사람 없이 몇 시간씩 돌아갈 수 있는 건 에이전트가 똑똑해서가 아니라, 하네스가 그 똑똑함이 이탈하지 않도록 가드레일을 쳐주기 때문이라고 느꼈습니다. 앞으로 제가 만들 에이전트 워크플로우도 triage → plan → execute → review 같은 단계를 명시적인 상태로 관리하고, 상태 전이 조건을 분명히 해서 에이전트의 행동을 예측 가능하고 디버깅 가능하게 만드는 방향이어야 한다고 생각합니다. 비결정적인 모델 위에 결정적인 하네스를 씌우는 구조가, 롱러닝 에이전트를 실제 업무에 투입할 수 있게 해주는 핵심이라는 확신이 들었습니다.

그 속도를 그대로 따라할 필요는 없겠지만, "AI를 믿고 바이브 에이전트로 일한다"는 태도의 전환은 더 이상 미룰 수 없어 보입니다. 빠르게 실행하고, 피드백을 하네스로 수렴시키고, 추상화 레벨을 올려서, 상태 머신 위에서 예측 가능한 에이전트를 돌리는 것. 이번 세미나가 저에게 남긴 숙제입니다.

References​

• Ralphthon x ULW Wrapup 행사 페이지
• Claw Code GitHub — 144K+ Stars, 역사상 가장 빠른 성장 속도
• UltraWorkers Discord — OMC, OMX, OMO 통합 커뮤니티

OMOcon Seoul이 4월 25일 강남역 근처에서 개최 예정이며 이미 500명 이상이 신청했습니다. Ralphthon은 5월 싱가포르에서 운동 세션을 포함한 Life Loop 해커톤으로 기획 중이고, 랄프톤 포맷을 프로토콜화하여 전 세계 어디서든 개최 가능하도록 만들 계획이라고 합니다.

vLLM Korea Meetup에 참석하여 LLM 서빙이 "좋은 모델을 띄우는 것"에서 **"클러스터 레벨에서 효율적으로 서빙하는 것"**으로 패러다임이 이동하고 있음을 체감했습니다. Production Stack(스퀴즈비츠), CXL 기반 KV Cache 공유(XCENA), On-Prem GPU 서빙(삼성전자), 오픈소스 모델 공개 노하우(Upstage), HyperCLOVAX 서빙기(네이버클라우드) 등 실전 경험을 들을 수 있었고, 특히 KV Cache 관리가 서빙 성능의 핵심 병목이라는 점이 모든 세션을 관통하는 키워드였습니다.

컨퍼런스 개요​

• 행사명: vLLM Korea Meetup (2nd)
• 일시: 2026년 4월 2일 18:00~22:00
• 장소: 오프라인 (메인홀 + 멀티룸 트랙)
• 주요 테마: vLLM 기반 Production-Level LLM 서빙
• 스폰서: 리벨리온, 스퀴즈비츠

트랙 구성:

인상 깊었던 세션​

1. vLLM Overall Update (리벨리온 + 레드햇)​

• 핵심 메시지: 지난 6개월간 vLLM 코어에 대규모 변화가 있었으며, v0에서 v1으로의 전환이 완전히 완료됨
• 주요 업데이트:
  • v0 deprecation 완료 (v0.11.0, 2025년 10월) — 디폴트 엔진을 v1으로 전환하고 v0 완전 제거
  • Async Scheduling 도입 — 스케줄링과 실행을 비동기적으로 분리하여 성능 향상
  • Model Runner V2 — 코어 컴포넌트 재설계로 연산·메모리 효율성 개선
• 리벨리온 업데이트: PyTorch 2.0 네이티브 지원으로 NPU 통합 강화, PyTorch RBLN 4월 10일 오픈 예정, Rebel 100 신제품 출시 (H200급 성능)
• Red Hat 업데이트: vLLM 0.18.2 릴리스, Semantic Router v0.2, GuideLLM(벤치마킹 도구), vLLM-Playground(개발 환경)
• 시사점: vLLM의 코어 아키텍처가 성숙 단계에 접어들면서, 이제는 에코시스템(Production Stack, Semantic Router 등)으로 관심이 이동하고 있음

2. vLLM Production Stack (스퀴즈비츠 김태수 CTO)​

• 핵심 메시지: 단일 vLLM 인스턴스만으로는 production-level 서빙이 불가능. Request Router + Shared KV Cache를 얹어야 클러스터 레벨 성능 확보 가능

• 3 Layer 아키텍처:
  1. Inference Amplification: vLLM 엔진의 코어 성능 (PagedAttention 등)
  2. Platform Layer: Observability, 쉬운 배포, Auto-scaling
  3. System Intelligence: Semantic Router를 통한 intelligent routing

• Router가 핵심: Round-robin이 아닌 prefix-aware, KV cache-aware, disaggregation-aware한 전략적 라우팅

• Cluster-level Cache Reuse: LMCache를 통해 다양한 tier storage 지원, Long context에서 prefix 재사용으로 TTFT 극적 단축

• Observability: Jaeger + OpenTelemetry 기반 트레이싱, W3C Propagation 지원 (v0.1.9~), 사전 정의된 대시보드 제공
• Auto-scaling: CPU/GPU 사용량이 아닌 inference-specific metrics(queue depth, latency) 기반
• 성능: 캐시 활용 시 310배 latency 개선, 23배 throughput 향상 (런칭 블로그 기준)

• 시사점: "모델이 아무리 좋아도 serving quality가 중요하다"는 메시지가 인상적. 우리 팀도 단일 인스턴스를 넘어 클러스터 레벨 서빙을 고려할 시점이 올 수 있음

3. LMCache & CXL 통합 여정 (XCENA 이주호님)​

• 핵심 메시지: KV Cache의 2대 과제는 "용량이 너무 크다"와 "빠르게 전송해야 한다". CXL이 이 두 가지를 동시에 해결할 수 있는 기술

• KV Cache 규모감:

  • 70B 모델, 128K context → 40GB
  • 5M context → 320GB
  • 클로드/GPT 급 서비스에서는 500GB 이상 추정

• CXL이란: PCIe 슬롯을 통해 DRAM을 확장하고, 여러 서버가 동일한 메모리에 나노초 레이턴시로 직접 접근(load/store)할 수 있는 프로토콜

• Maru: XCENA가 개발한 CXL 기반 KV Cache 스토리지 엔진 오픈소스 (GitHub)

  • LMCache에 스토리지 백엔드로 통합
  • 네트워크 전송 없이 메모리 주소만 공유하여 KV Cache 공유
  • 벤치마크: CXL 백엔드가 TCP 기반 P2P 대비 우수한 TTFT 성능

• 시사점: CXL은 아직 에코시스템이 초기 단계(스위치 비용 높음)이지만, KV Cache 공유 문제의 근본적 해결책이 될 수 있음. VectorDB에서도 CXL 활용 사례가 늘고 있다고 하니 주시할 필요 있음

업계 트렌드 & 시사점​

• "좋은 모델" → "좋은 서빙"으로 관심 이동: 작년까지는 모델 성능이 화두였지만, 올해는 서빙 품질(latency, throughput, scale-out)이 핵심 키워드
• KV Cache가 모든 세션을 관통하는 주제: Cache 압축(KV-Compress), Cache 공유(LMCache), Cache 저장(CXL) 등 다양한 레이어에서 연구 활발
• Kubernetes 네이티브 inference: Gateway Inference Extension, CRDs 등 K8s 생태계와의 깊은 통합이 진행 중
• PD Disaggregation 확산: Prefill과 Decode를 분리하는 아키텍처가 production 환경에서 실질적으로 도입되기 시작
• Observability의 중요성: 대규모 서빙에서 모니터링/메트릭 수집이 "있으면 좋은 것"에서 "필수"로 격상

팀 적용 포인트​

• LMCache 스터디: Prompt Caching 전략을 이미 다루고 있으니, LMCache를 통한 클러스터 레벨 KV Cache 공유 방안 검토
• Production Stack 테스트: 멀티 인스턴스 서빙이 필요한 시점에 vLLM Production Stack을 레퍼런스로 활용 가능. Helm Chart로 빠르게 PoC 가능
• Inference 메트릭 기반 Auto-scaling: GPU 사용률이 아닌 queue depth, latency 기반 스케일링 방식을 On-Prem 프로젝트에 적용 검토
• CXL 동향 모니터링: 당장 적용은 어렵지만, VectorDB + CXL 조합은 우리 RAG 파이프라인과 직결되는 주제. Maru 프로젝트 워치

전체 후기​

vLLM을 production level에서 실제로 사용해본 경험이 없어서 구체적으로 고민해본 적은 없었는데, 실제 서비스 단계에서 사용하려면 단순히 좋은 모델이 있는 것을 넘어서 latency를 줄이고 throughput도 고려하면서 효율적으로 좋은 성능을 내기 위한 노력이 필요하다는 것을 알게 되었다.

K8s, Helm, CXL, NPU, DRAM 등 인프라/하드웨어 레벨의 내용도 많이 등장해서 공부할 게 많다는 생각이 들었다.

References​

• vLLM Korea Meetup 이벤트 페이지
• vLLM GitHub Releases
• vLLM Production Stack
• Maru - CXL KV Cache Engine (XCENA)
• vLLM-RBLN 문서 (리벨리온)
• LMCache

AI 에이전트 평가는 전통적인 소프트웨어 테스트와 다르다. 복잡한 평가 시스템을 구축하기 전에 2050개의 실제 트레이스를 직접 읽고, end-to-end 태스크 완수를 검증하는 단순한 eval부터 시작하라. 6080%의 시간을 에러 분석에 투자하고, capability eval(무엇을 할 수 있는가)과 regression eval(여전히 작동하는가)을 명확히 분리하며, 차원별 전문 채점기를 설계하라. 프로덕션 트레이스를 지속적으로 데이터셋에 편입하는 플라이휠을 구축하면, 시간이 지남에 따라 에이전트가 개선된다.

Key Takeaways​

• 단순함부터 시작: 복잡한 인프라를 만들기 전에 30분간 실제 트레이스를 수동으로 읽어라. 자동 시스템보다 더 많은 실패 패턴을 발견할 수 있다.
• 에러 분석에 60~80% 투자: 실패 트레이스를 도메인 전문가와 함께 분석하여 프롬프트 문제, 툴 설계 문제, 모델 한계를 구분하고, 각 유형에 맞는 대응을 취하라.
• 평가 레벨의 전략적 선택: Single-step(툴 선택), Full-turn(end-to-end 태스크 완수 + 상태 변경), Multi-turn(대화 맥락 유지) 중 Full-turn부터 시작하여 안정화 후 확장하라.
• 차원별 전문 채점기: "정확성" 하나로 뭉뚱그리지 말고 콘텐츠 정확성, 구조, 포맷, 효율성 등 차원별로 독립된 채점기를 설계해 실패 원인을 명확히 파악하라.
• Trace-to-Dataset 플라이휠: 프로덕션의 성공/실패 트레이스가 자동으로 데이터셋에 편입되고, 개선된 에이전트가 다시 프로덕션에 배포되는 순환 구조가 장기적 개선의 핵심이다.

상세 내용​

에이전트 평가의 핵심 원칙​

AI 에이전트는 전통적인 소프트웨어와 근본적으로 다르다. 소프트웨어는 결정론적이고 코드가 진리의 원천이지만, 에이전트는 LLM의 추론에 의존하며 같은 입력에도 다른 경로를 선택할 수 있다. 에이전트가 200단계를 거쳐 2분간 작업한 후 실패했을 때, 스택 트레이스는 없다. 코드가 실패한 것이 아니라 추론이 실패한 것이기 때문이다.

가장 중요한 원칙은 단순함부터 시작하는 것이다. 몇 개의 end-to-end eval로 에이전트가 핵심 태스크를 완수하는지 검증하는 것만으로도 즉시 baseline을 확보할 수 있다. 복잡한 구조는 단순한 방법이 실제 실패를 놓칠 때만 추가한다.

Eval 구축 전 준비사항​

수동 트레이스 리뷰: 30분의 투자​

자동화된 평가 인프라를 만들기 전에 반드시 해야 할 일이 있다. 실제 에이전트 트레이스 20~50개를 직접 읽어라. 30분의 수동 리뷰가 어떤 자동 시스템보다 많은 실패 패턴을 알려준다. LangSmith의 트레이스 뷰어와 Annotation Queue를 활용하면 트레이스를 효율적으로 수집하고 검토할 수 있다.

에이전트는 LLM과 툴을 여러 턴에 걸쳐 호출하고, 중간 결과에 따라 행동을 조정하며, 상태를 수정한다. 이러한 복잡한 행동은 코드를 읽는 것만으로는 예측할 수 없으며, 실제 실행 트레이스가 진리의 원천이 된다.

명확한 성공 기준 정의​

두 명의 전문가가 pass/fail에 합의할 수 없다면, 태스크 자체를 재정의해야 한다.

나쁜 예: "이 문서를 잘 요약해줘"
좋은 예: "이 회의록에서 핵심 액션 아이템 3개를 추출하라. 각각 20단어 이내, 담당자가 언급되었으면 포함할 것"

모호한 기준은 채점기의 불일치를 만들고, 무엇이 개선인지 판단할 수 없게 만든다.

Capability Eval vs Regression Eval 분리​

이 두 가지는 목적이 완전히 다르기 때문에 반드시 분리해서 관리해야 한다.

• Capability Eval ("무엇을 할 수 있는가?"): 어려운 태스크에 대한 진전을 측정한다. 초기 pass rate가 낮고, 개선의 방향을 제시한다.
• Regression Eval ("여전히 작동하는가?"): 이미 작동하는 기능을 보호한다. pass rate가 ~100%여야 하며, 기존 기능의 퇴보를 감지한다.

Capability eval만 있으면 기존 기능이 깨지고, regression eval만 있으면 개선이 멈춘다. 두 가지 모두 필요하다.

에러 분석에 60~80% 투자하라​

전체 eval 노력의 60~80%를 에러 분석에 투자해야 한다. 이것이 가장 높은 ROI를 제공하는 활동이다. 절차는 다음과 같다:

1. 대표적인 실패 트레이스를 수집한다.
2. 도메인 전문가와 함께 사전 분류 없이 모든 이슈를 기록한다(open coding).
3. 이슈를 실패 유형으로 분류한다(프롬프트 문제, 툴 설계 문제, 모델 한계, 인프라 이슈 등).
4. 새로운 실패 유형이 나오지 않을 때까지 반복한다.

실패 유형에 따라 대응이 완전히 달라진다:

• 프롬프트 문제: 지시가 불명확 → 프롬프트 수정
• 툴 설계 문제: 인터페이스가 오용을 유발 → 파라미터 재설계, 예시 추가
• 모델 한계: 지시는 명확하지만 일반화 실패 → few-shot 예시 추가, 아키텍처 변경, 모델 교체
• 아직 모름: 충분한 실패 사례를 보지 못한 상태 → 에러 분석 계속

Anthropic 팀은 SWE-bench 에이전트를 만들 때 프롬프트 최적화보다 툴 인터페이스 최적화에 더 많은 시간을 썼다고 보고했다. 예를 들어 절대 경로를 강제하면 경로 관련 에러 전체를 제거할 수 있다.

Eval 오너십과 인프라 검증​

데이터셋 유지보수, 채점기 재캘리브레이션, 새 실패 모드 분류, "충분히 좋은" 기준 결정을 한 명의 도메인 전문가가 책임져야 한다. 위원회식 의사결정은 책임 소재를 흐리고 진전을 늦춘다.

또한 인프라 문제를 먼저 배제해야 한다. Witan Labs 팀은 단일 추출 버그를 고쳤을 때 벤치마크가 50%에서 73%로 뛴 사례를 보고했다. 타임아웃, 잘못된 API 응답, 오래된 캐시 같은 인프라 이슈가 추론 실패로 위장하는 경우가 잦다.

평가 레벨 선택​

에이전트 평가는 세 가지 레벨로 나뉘며, Trace-level(Full-turn)부터 시작하는 것을 권장한다.

Single-step Eval (Run 레벨)​

"올바른 툴을 선택했는가?", "유효한 API 호출을 생성했는가?"를 평가한다. 자동화가 가장 쉽지만, 에이전트 아키텍처가 안정적일 때만 유효하다. 아키텍처가 자주 바뀌는 초기 단계에서는 특정 툴 호출 패턴에 의존하는 평가가 빠르게 obsolete해진다.

Full-turn Eval (Trace 레벨)​

대부분의 팀이 시작해야 할 레벨이다. 세 가지 차원을 함께 평가한다:

• 최종 응답: 출력이 정확하고 유용한가?
• 경로(Trajectory): 합리적인 경로를 거쳤는가? (정확한 경로가 아닌, 유효한 경로)
• 상태 변경: 올바른 아티팩트가 생성되었는가? (파일 작성, DB 업데이트, 캘린더 이벤트 등)

상태 변경 검증은 자주 간과되지만 매우 중요하다. 에이전트가 "미팅 잡았습니다!"라고 말했더라도, 실제 캘린더에 올바른 시간·참석자·설명으로 이벤트가 존재하는지 확인해야 한다. 코딩 에이전트의 경우 생성된 파일이 실행 가능한지, 유닛테스트를 통과하는지 검증해야 한다.

Multi-turn Eval (Thread 레벨)​

가장 구현이 어렵다. Trace-level eval이 안정된 후에 추가한다. N-1 테스팅 기법이 유용하다: 프로덕션의 실제 대화에서 앞 N-1턴을 그대로 주고 마지막 턴만 에이전트가 생성하게 한다. 이를 통해 완전 합성 멀티턴 시뮬레이션의 compounding error를 회피할 수 있다.

데이터셋 구성 전략​

품질이 양을 이긴다​

검증된 20~50개가 미검증 수백 개보다 낫다. 모든 태스크는 참조 솔루션(reference solution)을 포함해야 하며, 이를 통해 태스크가 풀 수 있다는 것을 증명하고 채점의 기준선을 제공한다.

나쁜 예: "NYC행 좋은 항공편 찾아줘"
좋은 예: "SFO→JFK 왕복, 12/15~17 출발, 12/22 복귀, $400 이하, 이코노미"

포지티브 + 네거티브 케이스​

"검색해야 할 때 검색하는가?"만 테스트하면, 모든 것을 검색하는 에이전트에 최적화된다. 네거티브 케이스(해당 행동을 하면 안 되는 경우)도 반드시 포함해야 한다. Anthropic은 프론티어 모델이 정적 eval의 한계를 넘어서는 창의적 해법을 발견한 사례를 보고했다—Opus 4.5가 항공권 예약 문제에서 정책의 허점을 발견해 더 나은 해법을 제시했으나, 기존 채점기로는 "실패"로 판정되었다.

에이전트 유형별 맞춤​

• 코딩 에이전트: 결정적 테스트 스위트(유닛테스트 pass/fail) + 품질 루브릭
• 대화형 에이전트: 태스크 완수 + 상호작용 품질(공감, 명확성) 다차원 평가
• 리서치 에이전트: 근거성 체크(주장이 소스에 뒷받침되는가?) + 커버리지 체크(핵심 사실이 포함되었는가?)

데이터 소싱: 3가지 전략 병행​

1. 독파운딩(Dogfooding): 팀이 매일 에이전트를 스트레스 테스트하고, 모든 에러를 eval로 전환한다.
2. 외부 벤치마크 적응: Terminal Bench, BFCL 등에서 관련 태스크를 선별하여 자신의 에이전트에 맞게 변환한다.
3. 수작업 행동 테스트: "에이전트가 툴 호출을 병렬화하는가?", "모호한 요청에 명확화 질문을 하는가?" 등 특정 행동을 검증하는 테스트를 직접 작성한다.

Trace-to-Dataset 플라이휠​

프로덕션의 성공/실패 트레이스가 지속적으로 데이터셋에 편입되는 파이프라인을 구축한다. LangSmith를 사용하면 트레이스 → 어노테이션 큐 → 데이터셋 → 실험의 흐름을 자동화할 수 있다.

채점기(Grader) 설계​

차원별 전문 채점기​

하나의 "정확성" 채점기 대신 차원별로 분리하라. Witan Labs 팀은 콘텐츠 정확성, 구조, 시각 포맷, 수식 시나리오, 텍스트 품질 등 5개의 전문 평가기를 만들어 어디가 실패하는지 명확한 시그널을 얻었다.

객관적 정답이 있는 경우 코드 기반을 기본으로 사용한다. LLM-as-judge를 객관적 태스크에 쓰면 불일치가 실제 regression을 가릴 수 있다.

Guardrail vs Evaluator 구분​

바이너리 pass/fail 선호​

1~5점 척도는 인접 점수 간 주관적 차이를 만들고, 통계적 유의미성을 위해 더 큰 샘플이 필요하다. 바이너리는 더 명확한 사고를 강제한다: 성공했거나 실패했거나. 복잡한 태스크는 여러 개의 바이너리 체크로 분해한다.

LLM-as-judge 캘리브레이션​

• LangSmith Align Evaluator로 20개 이상의 라벨 예시로 시작, 프로덕션급 신뢰도를 위해 ~100개까지 확대
• 채점기의 출력에 **판단 근거(reasoning)**를 포함시켜 정확도를 높이고 감사 가능성 확보
• 정기적 재캘리브레이션 필수 — 채점기는 시간이 지나면 드리프트함
• few-shot 예시를 사용해 일관성 향상

결과를 채점하라, 경로가 아니라​

에이전트는 창의적인 경로를 찾는다. "check_availability → create_event 순서로 호출했는가?"가 아니라 **"미팅이 올바르게 잡혔는가?"**를 평가해야 한다. 다만 효율성 측정을 위해 이상적 경로 대비 실제 스텝 수를 추적하는 것은 유용하다. 이것은 정확성 채점이 아니라 효율성 메트릭이다.

부분 점수(partial credit)도 고려한다. 문제를 정확히 식별했지만 마지막 단계에서 실패한 에이전트는, 처음부터 실패한 에이전트보다 낫다.

커스텀 평가기 사용​

"helpfulness"나 "coherence" 같은 범용 메트릭은 거짓 확신을 만든다. 에러 분석에서 발견한 특정 실패 모드를 잡는 커스텀 평가기가 실제로 의미 있는 시그널을 준다. Deep Agents 팀은 각 eval에 docstring을 작성하여 무엇을 측정하는지 자체 문서화하고, tool_use 같은 카테고리 태그로 그룹 실행을 가능하게 한다.

실행 및 반복​

세 가지 평가 타이밍​

세 가지를 모두 활용해야 한다. Offline은 배포 전 품질 게이트, online은 프로덕션 모니터링, ad-hoc은 새로운 인사이트 발견에 각각 필수적이다.

비결정성 대응​

모델 출력은 실행마다 달라진다. 태스크당 여러 번 반복 실행하고, 개선을 선언하기 전에 신뢰구간을 계산한다. 제품 요구사항에 따라 pass@k(k번 중 1번 이상 성공) 또는 pass^k(k번 모두 성공) 메트릭을 선택한다.

실행 환경 격리​

시행 2가 시행 1의 아티팩트를 볼 수 있으면 결과가 독립적이지 않다:

• 코딩 에이전트: 시행마다 새 컨테이너/VM
• API 호출 에이전트: 스테이징 환경 또는 모의 서비스
• DB 에이전트: 시행 간 스냅샷 복원

메타데이터와 효율성 메트릭​

실험마다 모델, 프롬프트 버전, 검색 전략 등의 메타데이터를 기록하여, "GPT-4.1에서 Claude Sonnet으로 바꾸면 정확도가 오르는가?" 같은 질문에 답할 수 있게 한다.

품질과 함께 효율성 메트릭도 추적한다: 실제 스텝 수 / 이상적 스텝 수, 툴 호출 횟수, 토큰 사용량, 지연시간. 정확도 95%이지만 10배 느린 에이전트는 개선이 아닐 수 있다.

Pass Rate 정체 시 대응​

같은 유형의 태스크를 더 추가해도 새로운 실패 모드가 발견되지 않으면, 더 어려운 태스크를 추가하거나, 새로운 기능을 테스트하거나, 다른 차원으로 이동한다. 포화된 eval 세트를 반복하는 것은 시간 낭비다.

의미 있는 Eval만 유지하라​

모든 eval은 시스템에 압력을 가한다. 무분별하게 수백 개를 추가하면 프로덕션에서 중요하지 않은 것에 최적화하게 된다. 더 많은 eval이 더 나은 에이전트를 의미하지는 않는다. 주기적으로 시그널을 주지 않는 eval을 제거한다.

Task Failure vs Evaluation Failure 구분​

실행 상태를 명시적으로 추적한다(완료, 에러, 타임아웃). 타임아웃을 "추론 실패"로 채점하면 메트릭이 오염된다. 에이전트의 실패와 채점기의 실패를 분리해야 한다.

프로덕션 준비​

CI/CD 파이프라인 통합​

일반적인 흐름:

1. 코드/프롬프트 변경이 파이프라인을 트리거한다.
2. Offline eval 실행: 유닛테스트, 통합테스트, 큐레이션 데이터셋 대비 평가 (저비용·고속 코드 기반 채점기).
3. offline eval 통과 시 preview 배포.
4. preview에서 online eval 실행 (LLM-as-judge 채점기).
5. 모든 품질 게이트 통과 시에만 프로덕션 프로모트. 실패 시 해당 트레이스를 annotation queue로 라우팅하고 팀에 알림.

매 커밋마다 저비용 코드 기반 채점기를 CI에서 돌리고, 비용이 높은 LLM-as-judge는 preview/프로덕션 단계에 사용한다.

유저 피드백의 중요성​

자동 eval은 이미 알고 있는 실패 모드만 잡는다. 사용자가 발견하는 것들이 있다: 데이터셋이 놓친 엣지 케이스, 기술적으로는 맞지만 도움이 안 되는 출력, 예상 못한 방식으로 깨지는 워크플로우. 구조화된 피드백을 데이터셋에 편입하고, 채점기를 실제 기대치에 맞게 캘리브레이션하고, 사용자에게 실제로 중요한 개선에 우선순위를 둔다.

프로덕션 플라이휠​

프로덕션의 성공과 실패가 데이터셋, 에러 분석, eval 개선으로 되돌아가는 순환 구조를 구축한다. 이것이 에이전트를 시간이 지남에 따라 개선시키는 플라이휠이다:

프로덕션 트레이스 → 에러 분석 → 데이터셋 업데이트 → Eval 개선 → 에이전트 개선 → 프로덕션 배포 → (반복)

Capability → Regression 승격​

꾸준히 높은 pass rate를 보이는 capability eval을 regression suite로 승격한다. "할 수 있는가?"를 검증한 태스크가 "여전히 할 수 있는가?"를 보호하는 태스크로 전환된다.

전체 체크리스트 요약​

Eval 구축 전

• ☑️ 20~50개 실제 트레이스 수동 리뷰
• ☑️ 명확한 성공 기준 정의
• ☑️ Capability/Regression eval 분리
• ☑️ 실패 원인 식별 및 분류
• ☑️ 단일 도메인 전문가에게 오너십 부여
• ☑️ 인프라 문제 배제

평가 레벨 선택

• ☑️ Trace-level(Full-turn)부터 시작
• ☑️ 최종 응답 + 경로 + 상태 변경 함께 평가
• ☑️ 아키텍처 안정화 후 Single-step 추가
• ☑️ Multi-turn은 N-1 테스팅 기법 활용

데이터셋 구성

• ☑️ 모든 태스크에 참조 정답 포함
• ☑️ 포지티브 + 네거티브 케이스 균형
• ☑️ 검증된 20~50개부터 시작
• ☑️ 독파운딩 + 외부 벤치마크 적응 + 수작업 병행
• ☑️ Trace-to-Dataset 파이프라인 구축
• ☑️ 에이전트 유형별 맞춤 설계

채점기 설계

• ☑️ 차원별 전문 채점기 분리
• ☑️ Guardrail과 Evaluator 구분
• ☑️ 바이너리 pass/fail 선호
• ☑️ LLM-as-judge는 20+ 예시로 캘리브레이션
• ☑️ 결과를 채점, 경로는 효율성 메트릭으로
• ☑️ 에러 분석 기반 커스텀 평가기

실행 및 반복

• ☑️ Offline/Online/Ad-hoc 세 가지 타이밍 활용
• ☑️ 비결정성 대응: 반복 실행 + 신뢰구간
• ☑️ 실행 환경 격리
• ☑️ 메타데이터 + 효율성 메트릭 추적
• ☑️ 실패 트레이스 수동 검토
• ☑️ 포화된 eval 제거, 의미 있는 것만 유지
• ☑️ Task/Evaluation Failure 구분

프로덕션 준비

• ☑️ CI/CD 파이프라인 통합
• ☑️ 온라인 평가 지속 실행
• ☑️ 유저 피드백 구조화 수집
• ☑️ 프롬프트/툴 정의 버전 관리
• ☑️ Capability → Regression 승격
• ☑️ 프로덕션 플라이휠 구축

References​

• Agent Evaluation Readiness Checklist — Victor Moreira, LangChain
• Agent Observability Powers Agent Evaluation — LangChain
• How we build evals for Deep Agents — LangChain
• Demystifying Evals for AI Agents — Anthropic Engineering
• Building Effective Agents — Anthropic Research
• LLM Evals: Everything You Need to Know — Hamel Husain
• Witan Labs Research Log — Witan Labs

1979년 Apple II를 킬러앱으로 만든 VisiCalc을 500줄의 C 코드로 재구현한 프로젝트가 스프레드시트의 본질을 보여준다. 셀, 수식, 참조, 재계산이라는 핵심 추상화는 47년간 변하지 않았지만, 원본이 16KB RAM에서 동작한 반면 현대적 구현은 171KB를 사용한다. 전체 그리드 재계산 방식은 단순하지만, 실무급 스프레드시트에는 의존성 그래프 기반 증분 재계산이 필수적이다. 이 프로젝트는 데이터 모델링, 파싱, 의존성 관리, 반응형 UI가 결합된 프로그래밍의 축소판을 보여준다.

Key Takeaways​

• 스프레드시트의 데이터 모델은 극도로 단순하다: 각 셀은 EMPTY, NUM, LABEL, FORMULA 네 가지 타입 중 하나이며, 이 추상화는 1979년이나 2026년이나 동일하다
• 재귀 하강 파서(recursive descent parser)로 수식을 평가하면 연산자 우선순위가 호출 깊이로 자연스럽게 해결된다: 에러 처리는 IEEE 754의 NAN 전파 특성을 활용해 우아하게 구현 가능
• 전체 그리드 재계산은 구현은 쉽지만 실무에는 부적합하다: 수천 개 이상의 셀이 얽힌 실무 스프레드시트에서는 의존성 그래프 기반 증분 재계산이 필수적이며, 이는 빌드 시스템과 유사한 문제다
• 메모리 제약이 설계를 결정한다: 원본 VisiCalc은 16KB RAM에서 동작하기 위해 빈 셀에 메모리를 할당하지 않았지만, 현대적 정적 배열 구현은 171KB를 소비한다
• 표면적 단순함 아래 깊은 복잡성이 숨어있다: 파일 I/O, 상대/절대 참조, 순환 참조 감지, undo 같은 기능들이 실제 프로덕션 스프레드시트와 교육용 프로토타입을 구분한다

상세 내용​

셀이라는 보편적 추상화​

스프레드시트의 데이터 모델은 놀랄 만큼 단순하다. zserge의 구현에서 셀 하나는 타입 플래그, float 값, 그리고 사용자 입력 원문을 담는 128바이트 버퍼로 구성된다:

struct cell {
    int type;     // EMPTY, NUM, LABEL, FORMULA
    float val;
    char text[MAXIN];
};

그리드는 26열(A~Z) × 50행의 2차원 배열이다. 원본 VisiCalc은 256행 × 64열, 현대의 Excel은 104만 행 × 1만 6천 열을 지원하지만, 핵심 추상화는 동일하다.

이 구현의 정적 메모리 할당량은 약 171KB인데, 실제 Apple II의 16KB RAM에서는 절대 동작할 수 없는 크기다. 원본 VisiCalc이 어셈블리 수준에서 얼마나 극한의 메모리 최적화를 했는지 역으로 보여주는 대목이다. 빈 셀에는 메모리를 할당하지 않고, 입력된 셀만 동적으로 관리했을 가능성이 높다. 1979년의 메모리 관리는 그 자체로 하나의 엔지니어링 도전이었다.

재귀 하강 파서로 수식 평가하기​

VisiCalc에서 수식은 =가 아니라 +로 시작한다. +A1+A2*B1 같은 형태다. 이를 평가하기 위해 고전적인 재귀 하강 파서(recursive descent parser)를 구현했다.

파서 구조를 따라가면 컴파일러 교과서의 축약판을 읽는 느낌이다. 최상위 expr 함수가 덧셈·뺄셈으로 분리된 term을 처리하고, term은 곱셈·나눗셈으로 분리된 primary를 처리한다. primary는 숫자, 셀 참조, @SUM 같은 함수 호출, 괄호 표현식 중 하나다. 연산자 우선순위가 파서의 호출 깊이로 자연스럽게 해결되는 구조다.

struct parser {
    const char *s, *p;
    struct grid *g;
};

셀 참조 파싱도 흥미롭다. 단순히 sscanf로 A1을 읽을 수도 있지만, AB123 같은 다중 문자 열 이름도 지원하도록 직접 파싱한다. 열 문자를 26진법 숫자로 변환하고 행 번호를 정수로 읽는, 작지만 실용적인 설계다.

에러 처리는 NAN 전파로 우아하게 해결했다. NAN에 어떤 연산을 해도 NAN이 되는 IEEE 754 부동소수점의 특성을 활용한 것이다. 별도의 에러 코드나 예외 처리 없이 수식 체인 전체에 에러가 자연스럽게 퍼진다.

다만 원문의 코드 스니펫과 실제 GitHub 소스 사이에 불일치가 있다. 글에서 파서 구조체의 멤버는 pos(정수)로 정의되어 있지만, 본문 코드에서는 *p->p를 반복적으로 참조한다. GitHub의 실제 코드를 보면 멤버 변수가 const char *s, *p로 변경되어 있다. 따라해보려는 독자라면 GitHub 소스를 기준으로 삼는 게 안전하다.

재계산 전략: 단순함의 힘과 한계​

스프레드시트의 핵심 난제는 반응성(reactivity)이다. A1이 바뀌면 A1을 참조하는 모든 셀이 연쇄적으로 갱신되어야 한다. 이를 해결하는 방법은 크게 두 가지다: 의존성 그래프를 추적해서 변경된 셀만 정확히 갱신하거나, 전체 그리드를 반복 재계산하거나.

zserge는 원본 VisiCalc의 접근법을 따랐다. 셀이 변경될 때마다 전체 그리드를 행 우선 순서로 순회하며 모든 수식을 재평가한다:

void recalc(struct grid *g) {
    for (int pass = 0; pass < 100; pass++) {
        int changed = 0;
        // 전체 셀을 순회하며 수식 재평가
        // 값이 변경되면 changed = 1
        if (!changed) break;
    }
}

한 번의 패스로 모든 의존성이 해결되지 않을 수 있으므로(가령 A3이 A1을 참조하는데 A1의 수식이 아직 계산되지 않은 경우), 변경이 감지되지 않을 때까지 최대 100번 반복한다.

원본 VisiCalc은 이 재계산이 느려서 수동 재계산 명령(!)을 제공했고, 매뉴얼에서는 "모든 의존성이 해결될 때까지 여러 번 실행하라"고 안내했다. 당시 컴퓨터에서는 대형 스프레드시트의 재계산에 수 초가 걸렸기 때문이다.

zserge는 글에서 "의존성 그래프 유지는 대부분의 스프레드시트에서 과도한 설계(overkill)"라고 썼는데, 이 부분이 Hacker News에서 가장 뜨거운 반론을 불러일으켰다. 복수의 댓글이 "과도하기는커녕, 장난감 수준을 넘어서는 모든 스프레드시트에서 의존성 그래프는 절대적으로 필요하다"고 반박했다.

실제로 현대 Excel의 재계산 엔진은 정교한 의존성 추적 시스템 위에 구축되어 있다. Microsoft Research의 유명한 논문 "Build Systems à la Carte"는 스프레드시트를 일종의 빌드 시스템으로 분석하면서, 의존성 그래프 기반 증분 재계산이 왜 필수적인지를 이론적으로 보여준다. 수천 개의 셀이 복잡하게 얽힌 실무 스프레드시트에서 매번 전체를 재계산하면 사용자 경험이 심각하게 저하된다.

47년간 변하지 않은 것, 그리고 변한 것​

이 프로젝트가 증명하는 것은 스프레드시트의 핵심 추상화가 놀랍도록 안정적이라는 사실이다. 셀, 수식, 참조, 재계산, 그리드. 1979년이나 2026년이나 동일하다. VisiCalc을 FORTRAN 66으로 재구현해서 PDP-11에서 돌리는 프로젝트도 있고, VisiCalc의 원저자 Dan Bricklin이 직접 2008년경에 JavaScript로 만든 SocialCalc도 있다. 언어와 플랫폼이 바뀌어도 본질은 그대로다.

그런데 변하지 않은 것 못지않게, 47년 동안 쌓여온 복잡성도 주목할 만하다. 이 구현에서 빠진 것을 나열하면 오히려 현대 스프레드시트의 진짜 어려움이 보인다:

• 파일 I/O
• 수식 복사 시 셀 참조 자동 조정(상대/절대 참조)
• 열 너비 조절
• 행/열 고정
• 범위 이동
• 되돌리기(undo)
• 순환 참조 감지와 복구

한 교육자는 고등학생 AP 컴퓨터과학 수업에서 스프레드시트 구현을 프로젝트로 진행했는데, 일부 학생들의 구현이 "과하게 정교해져서" 보는 재미가 쏠쏠했다고 회상했다. 입력값을 원본 그대로 저장할지 가공해서 저장할지 같은 설계 판단에서 시니어 개발자도 배울 점이 있었다고 한다.

스프레드시트는 프로그래밍의 축소판이다. 데이터 모델링, 파싱, 의존성 관리, 반응형 UI가 모두 들어 있다. 500줄의 C 코드로 이 본질을 꺼내 보여준 것이 이 프로젝트의 진짜 가치다. 그리고 "그게 다가 아니다"라고 지적하는 커뮤니티의 토론이, 표면 아래에 숨은 깊이를 드러내 준다.

References​

• VisiCalc reconstructed - zserge
• 500줄의 C 코드로 되살린 VisiCalc, 47년간 변하지 않은 스프레드시트의 본질 - 박재홍의 실리콘밸리 위키독스 블로그
• Build Systems à la Carte - Microsoft Research

Moonshot AI가 제안한 Attention Residuals(AttnRes)는 Transformer의 고정된 잔차 연결을 학습 가능한 어텐션 메커니즘으로 교체하는 기법입니다. 각 레이어가 이전 레이어들의 출력을 균등하게 더하는 대신, 소프트맥스 어텐션으로 "어떤 깊이의 표현을 얼마나 참조할지" 학습하여 깊이 방향 게이팅을 구현합니다. Kimi Linear 48B 모델에서 GPQA-Diamond가 36.9→44.4로 향상되었고, 스케일링 법칙 실험에서는 기존 대비 1.25배 컴퓨트를 투입한 것과 동등한 성능을 보였습니다. Block AttnRes 변형은 메모리 오버헤드를 O(Ld)에서 O(Nd)로 줄여 실용성을 확보했습니다.

Key Takeaways​

• 깊이 방향 어텐션: 레이어 간 정보 흐름을 고정된 덧셈에서 학습 가능한 어텐션으로 전환하여 각 레이어가 필요한 깊이의 표현을 선택적으로 참조 가능
• 실질적 성능 개선: 다단계 추론(GPQA-Diamond +7.5점), 수학(Math +3.6점), 코드 생성(HumanEval +3.1점) 등 전 분야에서 일관된 향상
• 컴퓨트 효율성: 기존 방식 대비 약 20% 학습 컴퓨트 절감 효과로 대규모 모델 학습 비용 감소 및 AutoML/NAS 이터레이션 가속화
• Block AttnRes로 실용성 확보: 8개 블록으로 나누면 Full AttnRes 성능 대부분을 유지하면서 메모리 오버헤드를 획기적으로 감소
• 상호 보완적 개선: FlashAttention 등 효율성 중심 기법과 동시 적용 가능하여 품질과 효율성을 함께 향상

상세 내용​

기존 잔차 연결의 구조적 한계​

2017년 "Attention Is All You Need" 이후 Transformer 아키텍처의 근간은 놀라울 정도로 바뀌지 않았습니다. 멀티헤드 어텐션, FFN, 그리고 잔차 연결이 그대로 유지되고 있죠. 특히 잔차 연결은 ResNet 시절부터 이어져 온 "이전 레이어 출력을 그냥 더한다"는 단순한 방식을 거의 그대로 사용합니다.

현대 LLM의 표준인 PreNorm Transformer에서 잔차 연결은 매우 단순하게 작동합니다. 각 레이어의 출력을 이전까지의 누적값에 가중치 1로 그냥 더하는 구조로, 수식으로 표현하면 h_l = h_{l-1} + f_l(h_{l-1})입니다.

직관적이고 구현도 간단하지만, 레이어가 깊어질수록 두 가지 치명적인 문제가 발생합니다:

1. 은닉 상태의 무제한 증가: 레이어 수에 비례해 은닉 상태의 크기가 계속 커집니다
2. 레이어 기여도 희석: 40번째 레이어의 출력이 아무리 중요한 정보를 담고 있어도 앞선 39개 레이어의 누적값에 묻혀버립니다

Hacker News의 한 개발자는 이 문제를 명쾌하게 정리했습니다. "표준 방식에서는 첫 번째 레이어만 원본 입력을 직접 보고, 이후 모든 레이어는 이전 레이어의 출력만 봅니다. 각 레이어가 원본 입력이나 특정 중간 표현을 선택적으로 참조할 방법이 없습니다."

이 문제는 학계에서 꽤 오래전부터 알려져 있었지만, "그래도 잘 작동하니까"라는 이유로 근본적인 해결 없이 넘어가고 있었습니다.

AttnRes의 핵심: 깊이 방향 어텐션​

AttnRes의 아이디어는 개념적으로 깔끔합니다. 각 레이어가 이전 레이어들의 출력을 "균등하게 더하는" 대신, 소프트맥스 어텐션으로 "어떤 레이어의 출력을 얼마나 참고할지" 학습하게 만드는 것입니다.

구체적으로, l번째 레이어의 입력은 h_l = Σ α_{i→l} · v_i로 계산됩니다. 여기서 α는 학습된 가중치로, 이전 모든 레이어 출력에 대한 소프트맥스 어텐션 스코어입니다. 각 레이어는 d차원의 pseudo-query 벡터 w_l 하나만 추가로 학습하면 됩니다.

토큰 간 어텐션이 "어떤 토큰을 참조할까"를 학습하듯, AttnRes는 "어떤 깊이의 표현을 참조할까"를 학습합니다.

Hacker News에서 한 댓글은 이 구조가 LSTM의 입력 게이트(input gate)와 유사하다고 지적했습니다. LSTM이 이전 시간 스텝의 정보를 선택적으로 기억하고 잊는 것처럼, AttnRes는 이전 레이어의 정보를 선택적으로 조합합니다. 이전 시퀀스의 시간 축에서 하던 게이팅을 네트워크의 깊이 축으로 가져온 셈입니다.

어텐션 메커니즘 내부로의 확장​

Attention Residuals는 두 가지 차원에서 작동합니다. 첫째는 위에서 설명한 레이어 간 깊이 방향 어텐션이고, 둘째는 어텐션 연산 자체 내부에 잔차 경로를 추가하는 것입니다.

기존 트랜스포머에서 잔차 연결은 어텐션 블록의 바깥에 적용됩니다. 즉, output = input + Attention(input) 형태입니다. 하지만 어텐션 연산 내부에서는 이런 잔차 경로가 없었습니다.

기존 Self-Attention: Attention(Q, K, V) = softmax(QK^T / √d_k)V

Attention Residuals는 이 구조에 잔차 경로를 추가하여, 어텐션 출력이 단순히 가중합된 Value만이 아니라 원래 입력 정보도 직접적으로 보존하도록 합니다. 이를 통해 모델이 "이 토큰은 다른 토큰들을 참조할 필요가 적다"는 판단을 더 쉽게 할 수 있습니다.

특히 긴 시퀀스를 처리할 때 어텐션 스코어의 분포가 극단적으로 치우치는 현상(어텐션 싱크 등)을 완화하는 데 도움이 됩니다.

Block AttnRes: 실용성을 위한 타협​

Full AttnRes가 이론적으로 최적이지만, 실제 대규모 모델에 적용하면 O(Ld) 메모리가 필요합니다. 100개 이상의 레이어를 가진 최신 LLM에서는 무시할 수 없는 오버헤드입니다.

이를 해결하기 위해 제안된 Block AttnRes는 레이어들을 N개 블록으로 묶고, 블록 내부에서는 기존 잔차 연결을 사용하되 블록 간에만 어텐션을 적용합니다. 약 8개 블록으로 나누면 Full AttnRes 성능의 대부분을 회복하면서도 메모리 오버헤드를 O(Nd)로 줄일 수 있습니다.

연구팀은 이를 "실질적인 드롭인 대체제"로 제시합니다. Hacker News 커뮤니티에서도 이 블록 구조가 핵심이라는 반응이 많았습니다. 이론적으로 아름다운 Full AttnRes보다, 실제로 기존 모델에 바로 적용할 수 있는 Block AttnRes가 이 연구의 진짜 기여라는 것입니다.

구현 관점에서 보면, 이 기법은 기존 트랜스포머 코드에 최소한의 수정만으로 적용할 수 있다는 장점이 있습니다. 추가되는 파라미터도 적고, 연산 오버헤드도 크지 않습니다.

벤치마크: 숫자로 보는 실질적 개선​

연구팀은 Kimi Linear 48B(3B activated, MoE 구조) 모델에 1.4T 토큰을 학습시켜 비교했습니다. 결과는 전 분야에서 일관된 개선을 보여줍니다:

일반 추론

• MMLU: 73.5 → 74.6
• BBH: 76.3 → 78.0

다단계 추론 (가장 인상적)

• GPQA-Diamond: 36.9 → 44.4 (+7.5점)

수학 및 코드

• Math: 53.5 → 57.1
• HumanEval: 59.1 → 62.2
• MBPP: 72.0 → 73.9

중국어

• C-Eval: 79.6 → 82.5

스케일링 법칙 실험은 더 의미심장합니다. Block AttnRes를 적용한 모델이 기존 방식으로 1.25배 더 많은 컴퓨트를 투입해 학습한 모델과 동등한 손실값을 달성했습니다.

Hacker News의 한 댓글은 이를 "학습에 필요한 컴퓨트를 약 20% 절감하는 효과"로 해석하면서, 이것이 단순히 거대 모델 학습 비용을 줄이는 것 이상의 의미가 있다고 지적했습니다. 자동화된 모델 아키텍처 탐색(AutoML/NAS)의 이터레이션 속도도 그만큼 빨라지기 때문입니다.

어텐션 메커니즘 개선의 맥락​

어텐션 메커니즘의 개선은 현재 AI 연구에서 가장 활발한 분야 중 하나입니다:

• FlashAttention: 메모리 접근 패턴 최적화로 속도와 메모리 효율 개선
• MQA/GQA: Key/Value 헤드 공유로 추론 시 KV 캐시 메모리 절약
• Ring/Striped Attention: 시퀀스 분산 처리로 컨텍스트 길이 확장

Attention Residuals는 이들과 다른 축의 개선입니다. 위의 기법들이 주로 효율성(속도, 메모리)에 초점을 맞춘다면, Attention Residuals는 어텐션의 표현력과 학습 안정성이라는 품질 측면에 집중합니다.

중요한 것은 이 기법이 FlashAttention 등과 상호 보완적이라는 점입니다. 즉, 동시에 적용할 수 있어 효율성과 품질을 함께 개선할 수 있는 가능성이 있습니다.

한국 개발자를 위한 실무 적용 가이드​

LLM을 직접 학습하거나 파인튜닝하는 팀이라면 이 기법을 실험해볼 가치가 있습니다. 특히 다음 상황에서 효과적일 수 있습니다:

1. 긴 문서 처리: 한국어 모델에서 장문맥 처리 성능 개선
2. RAG 파이프라인: 컨텍스트 활용도가 떨어지는 문제 완화
3. 다단계 추론: GPQA-Diamond에서 보인 것처럼 복잡한 추론 태스크에서 특히 효과적

MoonshotAI는 중국의 AI 스타트업으로 Kimi라는 장문맥(long-context) LLM으로 알려져 있습니다. 이 팀이 어텐션 메커니즘 개선 연구를 공개한 것은, 긴 컨텍스트 처리에서 어텐션 메커니즘의 한계를 실제로 경험하고 그 해법을 모색한 결과일 가능성이 높습니다.

GitHub에 코드가 공개되어 있으므로, 기존 학습 코드에 통합하는 데 큰 어려움은 없을 것으로 보입니다. 다만 아직 초기 연구 단계이므로 다양한 태스크와 모델 규모에서의 검증이 필요합니다. 논문과 코드를 함께 살펴보며, 자신의 유스케이스에 맞는지 먼저 소규모 실험으로 확인하는 것을 권합니다.

학습 역학의 변화​

AttnRes가 벤치마크 수치 너머로 흥미로운 점은 학습 역학(training dynamics)의 변화입니다. 기존 PreNorm에서 레이어가 깊어질수록 개별 레이어의 기여도가 희석되는 문제를 해결하여, 각 레이어가 실제로 필요한 정보를 선택적으로 참조할 수 있게 됩니다.

이는 깊은 네트워크에서도 그래디언트가 안정적으로 흐르고, 각 레이어가 의미 있는 변환을 학습할 수 있는 환경을 제공합니다. PreNorm의 희석 문제를 완화하면서도 학습의 안정성은 유지하는 균형점을 찾은 것입니다.

References​

• Attention Residuals: Transformer의 잔차 연결을 '학습 가능한 어텐션'으로 바꾸자 - 박재홍의 위키독스 블로그
• MoonshotAI의 Attention Residuals: 트랜스포머 어텐션 메커니즘을 개선하는 새로운 접근 - TTJ 테크뉴스
• MoonshotAI Attention Residuals GitHub Repository

AI 에이전트 개발에서 컨텍스트 엔지니어링은 모델 파인튜닝보다 빠른 반복과 확장성을 제공한다. Manus 팀은 KV-cache 히트율을 핵심 지표로 삼아 지연시간과 비용을 최적화했으며, 프롬프트 접두사 안정화, 추가 전용 컨텍스트 설계, 명시적 캐시 중단점 설정 등의 원칙을 통해 에이전트 성능을 개선했다. 컨텍스트 구성 방식이 에이전트의 속도, 복구 능력, 확장성을 결정하는 핵심 요소다.

Key Takeaways​

• KV-cache 히트율이 프로덕션 AI 에이전트의 가장 중요한 지표: 캐시된 토큰 비용은 캐시되지 않은 토큰 대비 최대 10배 저렴하며(Claude Sonnet 기준), TTFT와 추론 비용에 직접적 영향을 미친다.
• 컨텍스트 엔지니어링이 파인튜닝보다 빠른 피드백 루프 제공: 모델 훈련은 주 단위 반복이 필요하지만, 컨텍스트 엔지니어링은 시간 단위로 개선사항 배포가 가능하여 PMF 탐색 단계에 적합하다.
• 프롬프트 접두사 안정성 유지가 필수: 단 하나의 토큰 변경도 이후 모든 캐시를 무효화하므로, 시스템 프롬프트에 타임스탬프 같은 동적 값을 포함하지 않아야 한다.
• 추가 전용(append-only) 컨텍스트 설계 원칙: 이전 작업이나 관찰을 수정하지 않고, JSON 직렬화 시 키 순서를 보장하여 캐시 일관성을 유지해야 한다.
• 에이전트는 챗봇과 다른 토큰 비율 특성: 평균 입력:출력 토큰 비율이 100:1로, 프리필링 단계가 압도적으로 많아 KV-cache 최적화가 더욱 중요하다.

상세 내용​

컨텍스트 엔지니어링의 전략적 선택​

Manus 팀은 프로젝트 초기에 중요한 기술적 분기점에 직면했다. 오픈소스 모델을 파인튜닝하여 엔드투엔드 에이전트를 구축할 것인가, 아니면 최신 LLM의 문맥 내 학습(in-context learning) 능력을 활용할 것인가?

BERT 시대의 NLP 개발 경험은 명확한 교훈을 제공했다. 당시 모델은 작았지만 파인튜닝과 평가에 주 단위 시간이 소요되었고, 이러한 느린 피드백 루프는 빠르게 변화하는 애플리케이션 개발, 특히 PMF(Product-Market Fit) 이전 단계에서 치명적인 단점이었다. GPT-3와 Flan-T5의 등장은 문맥 내 학습이라는 새로운 패러다임을 열었고, Manus는 여기에 베팅하기로 결정했다.

이 선택의 핵심 이점은 개선사항을 몇 주가 아닌 몇 시간 내에 배포할 수 있다는 점이다. 더 중요한 것은 제품이 기반 모델과 직교(orthogonal)하도록 유지한다는 점이다. "모델의 발전이 밀물이라면, Manus는 바닷바닥에 고정된 기둥이 아닌 배가 되고자 한다"는 표현이 이를 잘 설명한다.

KV-Cache 중심 설계의 중요성​

프로덕션 환경에서 AI 에이전트의 성능을 좌우하는 가장 중요한 단일 지표는 KV-cache 히트율이다. 이는 지연시간과 비용 모두에 직접적인 영향을 미친다.

에이전트의 작동 방식과 토큰 비율​

일반적인 에이전트는 다음과 같이 작동한다:

1. 사용자 입력 수신
2. 현재 컨텍스트 기반으로 액션 선택
3. 환경(예: VM 샌드박스)에서 액션 실행
4. 관찰 결과를 컨텍스트에 추가
5. 작업 완료까지 반복

이 과정에서 컨텍스트는 매 단계마다 증가하지만, 출력(주로 구조화된 함수 호출)은 상대적으로 짧다. Manus의 경우 평균 입력:출력 토큰 비율이 약 100:1로, 챗봇과 비교해 프리필링과 디코딩 간 비율이 극단적으로 치우쳐 있다.

비용 최적화의 핵심​

KV-cache를 활용하면 TTFT(Time To First Token)와 추론 비용을 극적으로 줄일 수 있다. Claude Sonnet을 예로 들면:

• 캐시되지 않은 토큰: 3 USD/MTok
• 캐시된 토큰: 0.30 USD/MTok
• 10배의 비용 차이

KV-Cache 히트율 향상을 위한 핵심 원칙​

1. 프롬프트 접두사를 안정적으로 유지​

LLM의 자기회귀적 특성상 단 하나의 토큰 차이만으로도 그 이후의 모든 캐시가 무효화된다. 흔한 실수는 시스템 프롬프트 시작 부분에 초 단위 타임스탬프를 포함하는 것이다. 모델이 현재 시간을 알 수 있게 하지만, 캐시 히트율을 심각하게 저하시킨다.

2. 컨텍스트를 추가 전용(Append-Only)으로 설계​

• 이전 작업이나 관찰을 수정하지 말 것
• 직렬화가 결정적(deterministic)이도록 보장
• 많은 프로그래밍 언어와 라이브러리가 JSON 객체 직렬화 시 안정적인 키 순서를 보장하지 않으므로 주의가 필요

3. 캐시 중단점을 명시적으로 표시​

일부 모델 제공업체나 추론 프레임워크는 자동 증분 접두사 캐싱을 지원하지 않는다. 이런 경우 컨텍스트에 수동으로 캐시 중단점을 삽입해야 한다. 캐시 만료 가능성을 고려하고, 최소한 시스템 프롬프트 끝을 포함하도록 설정해야 한다.

vLLM 같은 프레임워크로 모델을 자체 호스팅할 경우, 접두사/프롬프트 캐싱이 활성화되어 있는지 확인이 필요하다.

확률적 대학원생 하강법(Stochastic Graduate Descent)​

Manus 팀은 더 나은 컨텍스트 구성 방법을 발견할 때마다 에이전트 프레임워크를 네 번이나 재구축했다. 이러한 아키텍처 검색, 프롬프트 조정, 경험적 추측의 수동 프로세스를 팀은 "확률적 대학원생 하강법(Stochastic Graduate Descent, SGD)"이라고 부른다. 우아하지는 않지만 효과적이다.

컨텍스트 엔지니어링은 여전히 실험적 과학의 영역에 있으며, 수백만 사용자를 대상으로 한 실제 테스트를 통해 검증된 패턴이 중요하다.

미래를 위한 설계 원칙​

맥락(context)이 에이전트의 행동을 정의한다:

• 실행 속도
• 복구 능력
• 확장 가능성

모델이 더 강력하고, 빠르고, 저렴해지고 있지만, 아무리 뛰어난 능력도 메모리, 환경, 피드백의 필요성을 대체할 수 없다. 에이전트의 미래는 컨텍스트 하나하나로 구축될 것이다.

References​

• AI 에이전트를 위한 컨텍스트 엔지니어링: Manus 구축에서 얻은 교훈

Multi-vector retrieval 알고리즘 선택은 **유사도 함수(MaxSim/SumSim/Top-K Sum)**와 데이터 기하학(Isotropic/Anisotropic/Multi-Kernel) 두 축에 의해 결정된다. PLAID는 moderate variance + MaxSim 조합에, MUVERA는 isotropic 데이터에 최적화되어 있으며 이 조건을 벗어나면 성능이 급격히 저하된다. 흥미롭게도 SumSim은 mean-pooling으로 단일 벡터 MIPS로 환원 가능하며, ColPali는 per-token HNSW + 이진화로 32배 압축하면서도 94% recall을 유지할 수 있다. 임베딩 모델 학습 시 variance/isotropy 정규화를 통해 인덱싱 친화적 기하학을 설계할 수 있다는 점이 핵심이다.

Key Takeaways​

• 알고리즘 선택 전 데이터 기하학 분석이 필수: PLAID/MUVERA 도입 전에 intra-document variance와 anisotropy 정도를 정량화하라. 잘못된 조합은 centroid pruning 붕괴나 recall 저하를 초래한다.
• SumSim은 특수 인프라가 불필요: 내적의 bilinearity를 활용하면 mean-pooled 단일 벡터 MIPS로 환원되어 표준 HNSW/DiskANN으로 처리 가능하다.
• ColPali의 고정 cardinality는 게임 체인저: 1030개 고정 패치는 per-token HNSW + 이진화(32x 압축)로 효율적 처리가 가능하며, ~94% recall을 유지한다.
• Contrastive learning이 기하학을 결정: InfoNCE 손실의 온도 파라미터와 hard negative mining이 multi-kernel anisotropic 분포를 생성하며, 이것이 인덱싱 효율성에 직접 영향을 미친다.
• 모델 설계와 인덱싱은 독립적이지 않음: 학습 단계에서 variance/isotropy 정규화를 통해 PLAID나 MUVERA에 최적화된 임베딩 분포를 유도할 수 있다. 이는 PoBE(Preference-Optimized Binary Embedding) 같은 접근에 직접 활용 가능하다.

상세 내용​

Multi-Vector Retrieval의 두 가지 핵심 축​

전통적인 retrieval은 point-to-point MIPS(Maximum Inner Product Search)로 해결되지만, multi-vector retrieval은 본질적으로 집합 대 집합(set-to-set) 유사도 문제다. 각 문서와 쿼리는 단일 벡터가 아닌 임베딩 집합으로 표현된다: Q = {q₁, ..., qₘ}, P = {p₁, ..., pₙ}.

이 문제 공간은 두 개의 독립적인 축으로 분류할 수 있다:

1. 유사도 함수(Similarity Function): 두 집합 간 유사도를 계산하는 방법
2. 데이터 기하학(Dataset Geometry): 임베딩 공간 내 분포의 통계적 구조

대부분의 기존 논의는 MaxSim + ColBERT 스타일 분포라는 단일 조합에 집중되어 있으며, 이는 전체 문제 공간의 일부에 불과하다.

유사도 함수의 분류 체계​

MaxSim (Chamfer Similarity)

ColBERT의 표준 접근법으로, 각 쿼리 토큰에 대해 가장 잘 매칭되는 문서 토큰을 찾아 합산한다:

sim_MaxSim(Q, P) = Σᵢ max_j ⟨qᵢ, pⱼ⟩

• 비대칭적: 쿼리 토큰에 대해서만 합산 (문서→쿼리 방향은 고려하지 않음)
• Fine-grained alignment: 각 쿼리 토큰이 독립적으로 최적 매칭을 찾음
• Winner-takes-all 특성: 각 쿼리 토큰에 대해 단 하나의 문서 토큰만 기여

SumSim (All-Pairs)

모든 가능한 쿼리-문서 토큰 쌍의 유사도를 합산한다:

sim_SumSim(Q, P) = Σᵢ Σⱼ ⟨qᵢ, pⱼ⟩

• 대칭적: 모든 토큰이 동등하게 기여
• Cross-modal matching, group recommendation 등에 사용
• PLAID의 pruning 전략과 근본적으로 비호환

Top-K Sum

각 쿼리 토큰에 대해 상위 k개 문서 토큰의 유사도를 합산:

sim_TopK(Q, P) = Σᵢ Σ(j∈TopK) ⟨qᵢ, pⱼ⟩

• MaxSim (k=1)과 SumSim (k=|P|) 사이의 중간 지대
• k 증가 시 PLAID의 centroid pruning 효율성 감소

Symmetric Chamfer

양방향 MaxSim의 평균:

sim_SymChamfer(Q, P) = 1/2 [sim_MaxSim(Q, P) + sim_MaxSim(P, Q)]

저자의 핵심 지적: 현재 multi-vector retrieval 담론은 MaxSim을 문제 자체와 동일시하고 있으며, 다른 유사도 함수들은 체계적으로 무시되고 있다.

Dataset Geometry: 세 가지 기하학적 체제​

임베딩 분포의 통계적 구조는 인덱싱 알고리즘의 성능을 근본적으로 결정한다.

Gaussian Isotropic

모든 방향에서 균일한 분산을 가진 분포:

v ~ N(μ, σ²I)

• 이론적 분석에서 자주 가정되지만 실제로는 드묾
• 랜덤 하이퍼플레인 기반 LSH가 이론적 보장을 제공하는 체제

Gaussian Anisotropic

방향에 따라 분산이 다른 분포:

v ~ N(μ, Σ), Σ ≠ σ²I

• 특정 방향(주성분)으로 데이터가 "늘어난" 형태
• SimHash 같은 각도 기반 해싱에 문제 발생

Multi-Kernel Anisotropic

여러 Gaussian 클러스터의 혼합, 각 클러스터가 비등방적:

v ~ Σₖ πₖ · N(μₖ, Σₖ)

• 실제 학습된 임베딩의 현실적 분포
• ColBERTv2, ColPali 등이 이 체제에 속함
• Contrastive learning의 자연스러운 결과물

세 가지 기하학적 체제의 비교. 실제 multi-vector 임베딩은 Multi-Kernel Anisotropic 체제에 해당한다.

Contrastive Training이 만드는 기하학​

ColBERT의 InfoNCE 손실 함수는 특정 기하학적 구조를 유도한다:

온도 파라미터 τ의 역할

L_InfoNCE = -log [exp(⟨q, p⁺⟩/τ) / Σᵢ exp(⟨q, pᵢ⟩/τ)]

• τ는 클러스터 tightness를 제어하는 파라미터
• 낮은 τ → 더 촘촘한 클러스터 (equi-angular 형태)
• 높은 τ → 더 넓게 퍼진 분포

Hard Negative Mining의 영향

의미적으로 유사하지만 관련 없는 문서(hard negatives)를 명시적으로 구분하도록 학습하면:

L_hard = -log [exp(⟨q, p⁺⟩/τ) / (exp(⟨q, p⁺⟩/τ) + λ·Σ exp(⟨q, p⁻_hard⟩/τ))]

• 클러스터 간 경계 방향으로 방향성 늘어남(directional stretching) 발생
• Within-kernel 공분산이 비구형(non-spherical)이 됨
• 결과적으로 multi-kernel anisotropic 분포 생성

핵심 통찰: 하나의 금융 문서 내에서도 토큰들은 여러 의미적 역할(전문 용어, 기능어, 맥락 수식어)을 수행하며, 각각이 임베딩 공간의 다른 영역(다른 커널)에 매핑된다.

기하학 정량화 지표​

Intra-document variance (문서 내 분산)

σ²_intra(d) = 1/|P_d| Σᵢ ‖pᵢ - μ_d‖²
μ_d = 1/|P_d| Σᵢ pᵢ

• 높은 variance: 토큰들이 여러 의미 영역에 분산
• PLAID의 centroid pruning 효율성에 직접 영향

Residual magnitude (잔차 크기)

centroid 할당 후 잔차:

r_i = p_i - c_assigned(i)

• 큰 잔차: 양자화 시 재구성 노이즈 증가
• PLAID Stage 3의 신뢰도에 영향

문서별 intra-document variance 분포. ColPali 같은 vision 모델은 텍스트 모델보다 훨씬 높은 분산을 보인다.

PLAID의 기하학적 한계​

PLAID는 3단계 파이프라인으로 작동한다:

1. Centroid Pruning: 쿼리 토큰과 관련 없는 centroid 제거
2. Document Filtering: 관련 centroid만 포함한 문서로 후보 축소
3. Verification: 압축된 표현으로 정확한 MaxSim 계산

Centroid Pruning의 선택성 붕괴

문서 d가 활성화하는 고유 centroid 수:

n_d = |{c_i : ∃p ∈ P_d, c_i = argmin_c ‖p - c‖}|

PLAID의 선택성(제거되는 문서 비율):

selectivity = 1 - (n_d · n_query) / (C · N_docs)

• 높은 σ²_intra (예: ColPali) → n_d가 크게 증가
• C = 65,536인 경우, n_d가 수천 개로 증가하면 pruning이 거의 아무것도 제거하지 못함
• 결과: 거의 모든 문서가 Stage 2로 진입 → 계산 비용 급증

SumSim에서의 PLAID 붕괴

MaxSim의 "winner-takes-all" 특성:

• 각 쿼리 토큰에 대해 단 하나의 문서 토큰만 승리
• 비매칭 centroid는 max 연산에서 무시됨

SumSim의 "all-contribute" 특성:

• 모든 문서 토큰이 모든 쿼리 토큰에 기여
• Centroid pruning의 상한 기반 제거가 무의미해짐

PLAID Stage 2의 pruning 로직:

if max_i ⟨q_i, c_k⟩ < θ → centroid c_k 제거

이는 MaxSim에서만 유효하며, SumSim에서는:

contribution(c_k) = Σᵢ Σ(p∈cluster_k) ⟨qᵢ, p⟩

단일 쿼리 토큰과의 최대 유사도로 전체 기여를 상한할 수 없음.

Quantization 품질과 Residual Magnitude

ColBERTv2는 centroid ID + 2-bit 양자화 잔차로 압축:

재구성 오차: ‖p_i - (c_i + r_q)‖
MaxSim 근사 오차: |MaxSim_true - MaxSim_approx| ≤ Σᵢ ‖ε_i‖

MaxSim에서는 이것이 유효하지만, large residual을 가진 anisotropic 데이터에서는 2-bit 양자화가 significant noise를 도입한다.

Residual magnitude 분포. 큰 잔차는 양자화 노이즈를 증가시켜 PLAID의 정확도를 저하시킨다.

MUVERA의 기하학적 한계​

MUVERA는 SimHash 기반 파티셔닝으로 multi-vector 집합을 고정 차원 벡터(FDE)로 변환한다.

SimHash와 Anisotropy의 불협화음

b개의 랜덤 하이퍼플레인 {h₁, ..., h_b}를 사용. Isotropic 데이터에서 충돌 확률:

P_collision(u, v) = 1 - θ_uv/π

이는 각도만으로 결정되며, 균일 분포에서 이론적 보장이 성립한다.

그러나 Anisotropic 데이터에서는:

Σ = [σ₁² 0; 0 σ₂²], σ₁² >> σ₂²

주축(high variance 방향) u에 수직인 랜덤 하이퍼플레인이:

• ℓ₂ 거리에서 가까운 두 벡터를 다른 버킷으로 분리
• 유효 각도 θ_eff > θ_uv

Anisotropic 클러스터에서 SimHash의 문제. 주축에 수직인 하이퍼플레인이 가까운 이웃을 분리한다.

Over-Partitioning 문제

올바른 충돌 확률:

P_collision^(b) = (1 - θ_eff/π)^b

b에 대해 지수적으로 감소하여, 큰 b (fine-grained FDE)는 nearest neighbor 쌍을 다른 파티션으로 분리할 확률이 높아진다.

트레이드오프 딜레마:

• 작은 b: coarse FDE → 낮은 discrimination, 많은 false positive
• 큰 b: fine-grained FDE → nearest neighbor 분리, recall 저하

Multi-kernel anisotropic 공간에서 elongated within-kernel 분포는 SimHash의 이론적 보장을 무효화한다.

실용적 해결책 #1: SumSim은 Mean-Pooling으로 충분하다​

내적의 **bilinearity (쌍선형성)**를 활용한 핵심 증명:

sim_SumSim(Q, P) = Σᵢ Σⱼ ⟨qᵢ, pⱼ⟩
                 = Σᵢ Σⱼ qᵢᵀpⱼ
                 = (Σᵢ qᵢ)ᵀ (Σⱼ pⱼ)
                 = |Q| · |P| · ⟨μ_Q, μ_P⟩

여기서 μ_Q = (1/|Q|)Σᵢ qᵢ, μ_P = (1/|P|)Σⱼ pⱼ

SumSim이 mean-pooled 벡터 간 단일 내적으로 환원되는 과정.

실무 함의:

• SumSim 기반 retrieval (aggregate affinity, group recommendation, cross-modal matching)
• Mean-pooled representation을 오프라인 계산
• 표준 ANN 시스템으로 인덱싱: HNSW, DiskANN, ScaNN
• PLAID도, MUVERA도, 커스텀 인프라도 불필요

코드 예시:

# Multi-vector 대신 단일 벡터로 변환
doc_embedding_pooled = doc_embeddings.mean(dim=0)
query_embedding_pooled = query_embeddings.mean(dim=0)

# 표준 HNSW 인덱스 사용
index = hnswlib.Index(space='ip', dim=embedding_dim)
index.add_items(doc_embeddings_pooled)
results = index.knn_query(query_embedding_pooled, k=10)

# 필요 시 full multi-vector로 re-rank
for doc_id in results:
    exact_score = compute_sumsim(query_embeddings, doc_embeddings[doc_id])

실용적 해결책 #2: ColPali의 고정 Cardinality 활용​

ColPali는 ColBERT와 근본적으로 다른 특성을 가진다:

• ColBERT: 텍스트 길이에 따라 가변적인 토큰 수 (50~500+)
• ColPali: 페이지당 정확히 1030개 임베딩 (1024 image patches + 6 instruction tokens)

이 고정 cardinality는 완전히 다른 최적화 전략을 가능하게 한다.

Vespa의 Per-Token Nearest Neighbor 접근

Phase 0 (Pre-filtering):
  각 쿼리 토큰 qᵢ에 대해:
    - 이진화 임베딩으로 Hamming 거리 계산
    - k₀개 nearest page-patch 검색
    - 해당 페이지들의 union 생성

Phase 1 (Approximate MaxSim):
  생존 페이지들을 inverted Hamming distance로 스코어링
  상위 k₁개 유지

Phase 2 (Exact MaxSim):
  상위 k₁개를 full-precision float MaxSim으로 re-rank

Vespa 스타일 ColPali 검색 워크플로우. 이진화 + per-token HNSW + 단계적 reranking.

저장 비용 비교 (10억 페이지 기준):

32배 압축 + 최소 recall 손실이 핵심이다.

이진화 구현:

def binarize_embeddings(embeddings):
    """각 차원을 평균 기준으로 이진화"""
    threshold = embeddings.mean(dim=-1, keepdim=True)
    binary = (embeddings > threshold).to(torch.uint8)
    # 128 dim → 16 bytes
    return torch.packbits(binary, dim=-1)

def hamming_distance(binary1, binary2):
    """Hamming 거리 계산"""
    xor = binary1 ^ binary2
    return torch.popcnt(xor).sum()

# Per-token HNSW 인덱스
per_token_index = [
    hnswlib.Index(space='hamming', dim=16)  # 16 bytes
    for _ in range(1030)  # 각 패치 위치별 인덱스
]

# Phase 0: Per-token nearest neighbor
candidate_pages = set()
for query_token in query_embeddings:
    binary_query = binarize_embeddings(query_token)
    for token_idx, index in enumerate(per_token_index):
        nearest = index.knn_query(binary_query, k=100)
        candidate_pages.update(nearest)

# Phase 1: Approximate MaxSim with binary
# Phase 2: Exact MaxSim with float32

의사결정 프레임워크​

실무 체크리스트:

1. 데이터 기하학 먼저 분석:

   # Intra-document variance 측정
   for doc in corpus:
       embeddings = model.encode(doc)
       variance = embeddings.var(dim=0).mean()
       print(f"σ²_intra = {variance:.4f}")
   
   # Anisotropy 측정 (주성분 분산 비율)
   pca = PCA()
   pca.fit(all_embeddings)
   explained_variance_ratio = pca.explained_variance_ratio_
   anisotropy = explained_variance_ratio[0] / explained_variance_ratio[-1]
   

2. 유사도 함수 확인: MaxSim이 정말 필요한가? SumSim으로 충분하지 않은가?

3. 스케일 고려: 10M 문서 미만이면 brute-force도 실용적

4. 고정 cardinality 여부: ColPali 같은 경우 per-token 접근 고려

Embedding Model 설계 시사점​

저자의 가장 중요한 통찰: 학습 단계에서 인덱싱 친화적 기하학을 유도할 수 있다.

Intra-document Variance 정규화 (PLAID 최적화)

def variance_regularization_loss(embeddings, target_variance):
    """문서 내 분산을 목표값으로 정규화"""
    doc_variance = embeddings.var(dim=0).mean()
    return (doc_variance - target_variance) ** 2

# 전체 손실에 추가
total_loss = info_nce_loss + λ_var * variance_reg_loss

σ²_target을 codebook 크기에서 좋은 PLAID selectivity를 보이는 값으로 설정하면, 인덱싱 효율성을 모델에 내재화할 수 있다.

Within-kernel Isotropy 정규화 (MUVERA 최적화)

def isotropy_regularization_loss(embeddings, cluster_assignments):
    """각 클러스터 내에서 등방성 유도"""
    loss = 0
    for cluster_id in unique(cluster_assignments):
        cluster_embeds = embeddings[cluster_assignments == cluster_id]
        cov_matrix = torch.cov(cluster_embeds.T)
        eigenvalues = torch.linalg.eigvalsh(cov_matrix)
        # 고유값 분산 최소화 → 구형 클러스터
        loss += eigenvalues.var()
    return loss

더 둥근 클러스터 형태를 유도하여 랜덤 하이퍼플레인 파티셔닝과의 호환성 향상.

PoBE(Preference-Optimized Binary Embedding)에의 적용:

class GeometryAwareBinaryEmbedding(nn.Module):
    def forward(self, x):
        # 표준 임베딩
        embeddings = self.encoder(x)
        
        # Variance 정규화 (PLAID용)
        var_loss = variance_reg(embeddings, target=0.15)
        
        # Isotropy 정규화 (이진화 친화적)
        iso_loss = isotropy_reg(embeddings, self.clusters)
        
        # 이진화
        binary_embeds = torch.sign(embeddings - embeddings.mean())
        
        return binary_embeds, var_loss + iso_loss

핵심 메시지: 임베딩 모델 설계와 인덱싱 인프라는 독립적 선택이 아니다. 모델이 학습하는 기하학이 인덱스 성능을 직접 결정하며, 그 기하학에 대한 제어는 일반적으로 인식되는 것보다 훨씬 크다.

열린 연구 질문​

Geometry-Aware Hashing

랜덤 하이퍼플레인 대신 실제 공분산 구조 기반 파티셔닝:

• k-means LSH: 주성분 방향으로 파티션
• Learned hashing: 데이터 분포를 직접 학습

Visual Retrieval의 적절한 유사도 함수

ColPali가 MaxSim을 사용하는 것은 ColBERT로부터의 관성일 수 있음:

• 이미지 패치 간 유사도에는 다른 aggregation이 더 적절할 수 있음
• Spatial pooling, attention-weighted sum 등의 대안 탐구 필요

모델 스케일에 따른 기하학 변화

더 큰 모델이 더 isotropic한 임베딩을 생성하는가?

• 표현력 증가가 clustering 구조를 어떻게 변화시키는가?
• 인덱싱 친화도와

Sebastian Raschka가 운영하는 LLM Architecture Gallery는 GPT-2부터 최신 Frontier 모델까지 주요 LLM들의 아키텍처를 시각화하여 비교할 수 있는 참고 자료입니다. 각 모델의 파라미터 규모, 컨텍스트 길이, 어텐션 메커니즘, 디코더 타입 등 핵심 사양을 한눈에 파악할 수 있으며, GPT-2의 기본 Dense 구조부터 DeepSeek V3의 MoE, xLSTM 등 다양한 아키텍처 진화를 추적할 수 있습니다. AI Research Engineer가 문제 상황에 맞는 적절한 모델 선택과 아키텍처 설계 인사이트를 얻을 수 있는 실무 레퍼런스입니다.

Key Takeaways​

• 아키텍처 진화 추적: GPT-2(1.5B, MHA)부터 최신 Frontier 모델(DeepSeek V3 671B, Llama 4 400B 등)까지 디코더 구조, 어텐션 메커니즘(MHA → GQA → MoE), 정규화 기법의 변화를 체계적으로 비교 가능
• 스케일별 설계 패턴: 소형(1B-8B), 중형(24B-32B), 대형(120B-400B), 초대형(671B-1T) 파라미터 범위별로 서로 다른 아키텍처 선택(Dense vs MoE, Attention 전략)을 확인할 수 있어 프로젝트 요구사항에 맞는 모델 선택 기준 제공
• 기술적 디테일 확인: 각 모델의 config.json, 라이선스, 컨텍스트 길이, 포지셔널 임베딩 방식(Absolute → RoPE), Key detail 등 실무 구현에 필요한 정보를 팩트시트로 제공
• 다양한 혁신 사례: xLSTM(7B)처럼 Transformer 외 아키텍처, Linear Attention을 활용한 Kimi 시리즈, MoE 최적화를 보여주는 Qwen3/DeepSeek 계열 등 실험적 접근법 학습 가능
• 지속적 업데이트: 2026년 3월까지 업데이트되며(최신 Mistral Large 3 673B, GLM-5 744B 등 포함) 물리적 포스터로도 제공되어 팀 학습 및 레퍼런스용으로 활용 가능

상세 내용​

LLM Architecture Gallery 소개​

Sebastian Raschka 박사가 운영하는 LLM Architecture Gallery는 현대 대규모 언어모델들의 아키텍처를 체계적으로 정리한 시각적 참고 자료입니다. 이 갤러리는 그의 주요 아티클인 "The Big LLM Architecture Comparison", "From GPT-2 to gpt-oss", "From DeepSeek V3 to V3.2", "A Dream of Spring for Open-Weight LLMs" 등에서 다룬 아키텍처 다이어그램과 팩트시트를 한 곳에 모아놓은 것입니다.

Provider LLM(Frontier 급 모델)을 주로 사용하는 실무 환경에서도 각 모델의 내부 아키텍처를 이해하면 LLM 기반 문제에 더 유연하고 전략적으로 접근할 수 있습니다. 예를 들어 레이턴시가 중요한 상황에서는 Dense 모델을, 대규모 처리에는 MoE 구조를 선택하는 등의 의사결정이 가능해집니다.

베이스라인: GPT-2부터 시작하기​

갤러리는 GPT-2 XL (1.5B) 을 Late-2019 dense baseline으로 포함하여, Transformer 디코더 스택이 GPT-2 이후 얼마나 변화했는지 비교할 수 있는 기준점을 제공합니다.

GPT-2 XL 주요 사양:

• Scale: 1.5B 파라미터
• Context: 1,024 토큰
• Decoder type: Dense
• Attention: MHA(Multi-Head Attention) with learned absolute positional embeddings
• Key detail: Dropout, GELU, LayerNorm을 사용한 클래식 GPT-2 레시피

이 기본 구조를 이해하면 이후 모델들이 어떤 방향으로 최적화되었는지(GQA 도입, RoPE 사용, Pre-norm 전환 등) 명확히 파악할 수 있습니다.

주요 모델 아키텍처 비교​

Llama 계열의 진화​

**Llama 3 (8B)**는 GPT-2 대비 진화된 Reference dense stack을 보여줍니다:

• Attention: GQA(Grouped Query Attention) with RoPE
• Context: 8,192 토큰 (GPT-2의 8배)
• Key detail: Pre-norm 구조로 학습 안정성 향상
• License: Llama 3 Community License

**Llama 3.2 (1B)**는 소형 모델 카테고리에서 Qwen 등과 비교되는 벤치마크를 제공하며, **Llama 4 Maverick (400B)**는 초대규모 모델의 최신 사례를 보여줍니다.

MoE 아키텍처: DeepSeek & Qwen​

DeepSeek V3 (671B) 와 V3.2는 Mixture-of-Experts 구조를 활용한 효율적인 초대규모 모델의 대표 사례입니다:

• 전체 671B 파라미터를 가지면서도 실제 활성화되는 파라미터는 일부만 사용
• DeepSeek R1 (671B)는 Reasoning 능력을 강화한 변형

Qwen3 계열은 다양한 스케일에서 MoE를 적용:

• Qwen3 (235B-A22B): 235B 총 파라미터, 22B 활성 파라미터
• Qwen3 Next (80B-A3B): 더욱 aggressive한 sparsity
• Qwen3 (32B), (8B), (4B): Dense 구조로 다양한 규모 지원

극소형 모델: SmolLM & Nanbeige​

SmolLM3 (3B) 와 Gemma 3 (270M) 같은 소형 모델들은 Edge 디바이스나 리소스 제약 환경에서 중요합니다. Nanbeige 4.1 (3B) 와 Tiny Aya (3.35B) 는 특정 언어나 도메인에 특화된 경량 옵션을 제공합니다.

실험적 아키텍처: xLSTM​

xLSTM (7B) 은 Transformer가 아닌 LSTM 기반 접근법으로, 장기 의존성 처리와 메모리 효율성에서 다른 관점을 제시합니다. 이는 Attention 메커니즘의 대안을 탐구하는 연구자들에게 중요한 레퍼런스가 됩니다.

초대규모 모델들​

1T(1조) 파라미터급 모델들도 포함되어 있습니다:

• Kimi K2 (1T), K2.5 (1T): Linear Attention 활용
• Ling 2.5 (1T): 중국어 특화
• GLM-5 (744B): 최신 초대규모 모델

이들은 주로 MoE 구조를 통해 실제 inference 비용을 관리하며, 각기 다른 최적화 전략을 보여줍니다.

핵심 기술 요소 비교​

Attention 메커니즘 진화​

1. MHA (Multi-Head Attention): GPT-2 시대 표준
2. GQA (Grouped Query Attention): Llama 3, OLMo 등에서 KV cache 효율화
3. MoE: DeepSeek, Qwen, Mistral Large 등에서 조건부 계산
4. Linear Attention: Kimi 시리즈에서 긴 컨텍스트 처리 최적화

포지셔널 임베딩​

• Learned Absolute: GPT-2
• RoPE (Rotary Position Embedding): 대부분의 현대 모델 표준

정규화 전략​

• Post-norm: 초기 Transformer
• Pre-norm: Llama, OLMo 등 현대 모델의 표준 (학습 안정성)

실무 활용 방법​

1. 모델 선택 기준 수립: 프로젝트의 레이턴시, 처리량, 메모리 제약에 따라 Dense(작은 규모, 예측 가능한 성능) vs MoE(큰 규모, 효율적 처리) 선택
2. 아키텍처 벤치마킹: 유사 규모 모델들(예: 7B-8B Dense 그룹)의 설계 차이점 비교로 최적화 아이디어 도출
3. 라이선스 확인: 각 팩트시트의 License 정보로 상업적 사용 가능 여부 즉시 파악
4. 구현 레퍼런스: config.json 링크와 Tech report로 재현 가능한 구현 세부사항 확인
5. 팀 교육 자료: Redbubble 포스터(Medium 사이즈: 26.9 x 23.4 inches 권장)를 활용한 오프라인 학습 환경 구축

지속적인 업데이트​

갤러리는 2026년 3월 20일까지 업데이트되었으며, 새로운 모델이 출시될 때마다 지속적으로 추가됩니다. 부정확한 팩트시트나 링크 오류는 Architecture Gallery issue tracker를 통해 제보할 수 있습니다.

최근 추가된 모델 예시:

• Mistral Large 3 (673B)
• GLM-4.7 (355B)
• Nemotron 3 Super (120B-A12B)
• Arcee AI Trinity Large (400B)
• Sarvam (30B, 105B)

학습 커뮤니티와 지속적 성장​

Sebastian Raschka는 이 갤러리 외에도 "LLMs From Scratch" 코스, AI Newsletter, Reasoning Models 분석 등을 통해 LLM 생태계의 최신 지식을 공유하고 있습니다. LLM 아키텍처는 계속 진화하고 있으며, Frontier 모델을 사용하는 엔지니어도 내부 동작 원리를 이해함으로써 더 나은 프롬프트 엔지니어링, 파인튜닝 전략, 배포 최적화를 수행할 수 있습니다.

"다같이 평생 공부합시다"라는 원본 문서의 메시지처럼, 이 갤러리는 AI Research Engineer가 지속적으로 최신 아키텍처 트렌드를 따라가고 더 넓은 시각에서 LLM 기반 문제에 유연하게 대응할 수 있도록 돕는 살아있는 레퍼런스입니다.

References​

• LLM Architecture Gallery - Sebastian Raschka
• Architecture Gallery Issue Tracker
• LLM Architecture Gallery Poster - Redbubble
• Sebastian Raschka's Blog

보안 연구자 Can Boluk는 LLM의 코드 편집 인터페이스(하네스)만 개선하여 16개 모델의 성능을 극적으로 향상시켰다. "Hashline"이라는 새로운 편집 도구는 각 코드 줄에 2~3자리 해시를 부여해 정확한 문자열 재현 없이 줄 참조를 가능하게 했다. 그 결과 Grok Code Fast 1 모델은 6.7%에서 68.3%로 성능이 급증했고, 평균 출력 토큰은 20% 감소했다. 모델 자체는 전혀 변경하지 않고 도구 인터페이스만 바꾼 성과다.

Key Takeaways​

• 하네스(Harness) 설계가 모델 성능의 병목: 어떤 모델이 가장 우수한가보다 모델과 코드베이스 간 인터페이스가 실제 성능을 좌우한다. Claude나 OpenAI의 기본 도구는 특정 모델에 최적화되어 있어 다른 모델에선 실패율이 50% 이상 발생한다.
• 줄 해시 기반 참조의 혁신: Hashline은 정확한 문자열 매칭 대신 2~3자리 해시로 코드 줄을 식별해, 모델이 긴 문자열을 재현할 필요를 없앴다. 이는 토큰 효율성과 편집 정확도를 동시에 개선한다.
• 모델 비의존적 최적화: 동일한 하네스 개선이 GPT-4o, Claude Sonnet, Gemini 등 15개 이상의 모델에서 일관되게 성능 향상을 보였다. 이는 프롬프트 엔지니어링보다 도구 인터페이스 설계가 더 범용적인 개선 방법임을 시사한다.
• 실무 적용 가능성: 기존 str_replace나 apply_patch 도구의 한계(긴 인덴트 처리, 특수문자 이스케이핑 등)를 인지하고, 간단한 해시 기반 인터페이스로 대체하면 즉각적인 성능 개선이 가능하다.
• 토큰 경제성: 출력 토큰 20% 감소는 비용 절감뿐 아니라 응답 속도 개선으로 이어지며, 이는 프로덕션 환경에서 직접적인 사용자 경험 향상으로 연결된다.

상세 내용​

하네스 문제: 간과된 병목 지점​

AI 코딩 어시스턴트 논의는 대부분 "어떤 모델이 최고인가"에 집중한다. GPT-5.3 vs Opus, Gemini vs 이번 주 출시된 신모델. 하지만 Can Boluk는 이 프레임이 근본적으로 오해를 유발한다고 지적한다. 실제 병목은 훨씬 평범한 곳에 있다: 하네스(harness).

하네스는 단순한 UI가 아니다. 모든 입력 토큰의 소스이자, 모델의 출력과 실제 코드베이스 변경 사이의 인터페이스다. Claude Code는 여전히 서브에이전트 출력에서 원시 JSONL을 유출하며 수십만 토큰을 낭비한다. 도구 스키마, 에러 메시지, 상태 관리 등 "모델이 무엇을 바꿀지 안다"와 "문제가 실제로 해결된다" 사이의 모든 것이 하네스 영역이며, 실무에서 대부분의 실패가 발생하는 지점이다.

Boluk는 오픈소스 코딩 에이전트 Pi의 포크인 oh-my-pi를 유지보수하며 1,300개 이상의 커밋을 작성했다. 모델 비의존적 설계 덕분에 모델은 단순한 파라미터가 되고, 진짜 변수는 하네스가 된다. 바로 여기서 "상상 이상의 제어권"을 행사할 수 있다.

기존 편집 도구의 한계​

현재 주류 편집 도구는 두 가지다:

1. OpenAI Codex의 apply_patch OpenAI 특화 diff 형식의 문자열 블롭을 입력받는다. 구조화된 스키마가 아닌 엄격한 규칙을 따르는 텍스트다. OpenAI 게이트웨이에서 토큰 선택 프로세스가 이 구조에 맞게 편향되어 있을 것으로 추정되지만, 다른 모델에 적용하면 패치 실패율이 급증한다. Grok 4는 50.7%, GLM-4.7은 46.2%의 실패율을 기록했다. 모델이 나쁜 게 아니라 "언어를 모르는" 것이다.

2. Claude Code의 str_replace 대부분의 도구가 채택한 방식이다. "이 정확한 문자열을 찾아서 저것으로 교체해라." 간단하지만 치명적인 문제들이 있다:

• 인덴테이션 지옥: 긴 인덴트를 포함한 문자열을 정확히 재현해야 함
• 특수문자 이스케이핑: JSON/XML 컨텍스트에서 따옴표, 개행 등을 올바르게 이스케이프해야 함
• 토큰 낭비: 변경하려는 줄 전체를 두 번(원본과 교체본) 재현해야 함
• 미묘한 불일치: 공백 하나 차이로 전체 편집이 실패

이런 도구들은 특정 모델(GPT 계열, Claude 계열)에 최적화되어 있어, 다른 모델은 구조적으로 불리한 위치에 놓인다.

Hashline: 해시 기반 줄 참조​

Boluk의 해결책은 우아하게 단순하다. 파일의 각 줄에 2~3자리 해시를 부여한다:

1:a3|function hello() {
2:f1|  return "world";
3:0e|}

모델이 편집을 요청할 때는 이렇게 말한다:

"2:f1 줄을 다음으로 교체: return 'universe';"

정확한 문자열 재현이 필요 없다. 해시가 줄을 고유하게 식별하므로, 모델은 짧은 참조만으로 위치를 지정할 수 있다. 이는:

• 토큰 효율성: 긴 문자열 재현 불필요
• 오류 감소: 인덴트나 이스케이핑 실수 원천 차단
• 범용성: 모델 특화 편향 없이 모든 LLM이 동일하게 사용 가능

벤치마크 결과: 극적인 성능 향상​

결과는 놀라웠다:

• Grok Code Fast 1: 6.7% → 68.3% (10배 이상 향상)
• 전체 모델 평균 출력 토큰: 약 20% 감소
• 16개 모델 전반에 걸친 일관된 개선

중요한 점은 모델 가중치를 전혀 건드리지 않았다는 것이다. 파인튜닝도, 프롬프트 대수술도 없었다. 순전히 편집 도구 하나만 바꿨다.

이는 현재 LLM 코딩 성능 논의가 얼마나 잘못된 지점에 집중하고 있는지 보여준다. "어떤 모델이 최고인가"보다 "어떤 인터페이스로 모델을 활용하는가"가 실제 성능을 좌우한다.

실무적 시사점​

1. 하네스 설계는 모델 선택만큼 중요하다 프로덕션 코딩 어시스턴트를 구축한다면, 모델 API 선택에 쏟는 시간만큼 도구 인터페이스 설계에 투자해야 한다. 기존 도구(str_replace, apply_patch)의 한계를 이해하고, 당신의 유즈케이스에 맞는 인터페이스를 설계하라.

2. 모델 비의존적 최적화의 가치 Hashline의 개선은 GPT, Claude, Gemini, Grok 등 다양한 모델군에 걸쳐 작동했다. 특정 모델에 종속된 최적화보다 범용적인 인터페이스 개선이 장기적으로 더 큰 가치를 제공한다. 모델은 계속 바뀌지만, 좋은 하네스는 남는다.

3. 토큰 경제성과 사용자 경험 20% 토큰 감소는 단순 비용 절감이 아니다. 응답 속도가 빨라지고, 컨텍스트 윈도우를 더 효율적으로 사용할 수 있으며, 사용자는 더 빠른 피드백을 받는다. 토큰 레벨의 최적화가 직접적인 UX 개선으로 이어진다.

4. 오픈소스와 실험의 중요성 Boluk의 발견은 상업적 제품(Claude Code, Cursor 등)이 놓친 지점이다. 모델 비의존적인 오픈소스 하네스에서 자유롭게 실험할 수 있었기에 가능했다. AI 인프라 스택에서 오픈소스 레이어의 가치를 재확인하는 사례다.

더 넓은 맥락: Harness Engineering의 부상​

Hashline 실험은 새로운 엔지니어링 디시플린의 필요성을 보여준다: Harness Engineering. 프롬프트 엔지니어링이 모델에게 "무엇을 요청할지"를 다룬다면, 하네스 엔지니어링은 "어떻게 상호작용할지"를 설계한다.

좋은 하네스는:

• 모델의 출력을 실행 가능한 액션으로 신뢰성 있게 변환한다
• 토큰 효율성을 극대화한다
• 다양한 모델에 걸쳐 작동한다
• 에러 핸들링과 상태 관리를 우아하게 처리한다

이는 단순한 UI/UX 문제가 아니다. 분산 시스템 설계, API 설계, 컴파일러 인터페이스 설계와 맥을 같이하는 시스템 엔지니어링 문제다.

결론: 도구가 모델만큼 중요하다​

Can Boluk의 실험은 명확한 메시지를 전달한다: 당신의 AI 시스템 성능은 가장 약한 고리, 즉 하네스에 의해 결정된다. 최신 최고 모델을 사용하더라도, 형편없는 편집 인터페이스는 그 잠재력을 절반도 끌어내지 못한다.

실무 AI 엔지니어로서 우리는 모델 선택뿐 아니라 인터페이스 설계에 진지하게 투자해야 한다. Hashline은 하나의 예시일 뿐이다. 당신의 도메인, 당신의 워크플로우에는 또 다른 "해시라인"이 기다리고 있을 수 있다. 모델 벤치마크를 쫓는 대신, 하네스를 해킹하라.

References​

• I Improved 15 LLMs at Coding in One Afternoon. Only the Harness Changed. - Can Boluk
• oh-my-pi - GitHub Repository (추정)
• Pi - Original Open-Source Coding Agent (추정)

AI 에이전트가 복잡한 프로덕션 환경에서 안정적으로 동작하려면 프롬프트와 컨텍스트 설계만으로는 부족합니다. 하네스 엔지니어링(Harness Engineering)은 에이전트를 감싸는 전체 환경—저장소 구조, CI/CD, 린터, 외부 도구 연결, 피드백 루프—을 설계하는 새로운 엔지니어링 패러다임입니다. OpenAI의 실험에서 하네스만 제대로 구축했을 뿐인데 AI가 백만 라인의 프로덕션 소프트웨어를 완성했으며, 이는 엔지니어의 역할이 "코드 작성"에서 "환경 설계"로 전환되고 있음을 보여줍니다. 프롬프트 엔지니어링이 "무엇을 물어볼까"에 집중한다면, 컨텍스트 엔지니어링은 "무엇을 보여줄까", 하네스 엔지니어링은 "전체 환경을 어떻게 설계할까"라는 질문에 답합니다.

Key Takeaways​

• 하네스는 에이전트의 "운영체제"다: 린터, CI/CD, 아키텍처 가드레일, 외부 도구 연결 등 에이전트 바깥의 모든 제약과 피드백 장치가 하네스를 구성하며, 이것이 프롬프트보다 더 큰 영향을 미친다.
• 프롬프트 → 컨텍스트 → 하네스 순서로 범위가 확장된다: 프롬프트 엔지니어링이 "지시문 최적화"라면, 컨텍스트 엔지니어링은 "LLM이 보는 모든 정보 설계", 하네스 엔지니어링은 "에이전트를 감싸는 시스템 전체 설계"다.
• 컨텍스트는 많이 넣는다고 좋은 게 아니다: Context Poisoning, Distraction, Confusion 같은 실패 패턴이 존재하며, 컨텍스트 윈도우를 "딱 맞는 정보"로 채우는 것이 핵심이다(Karpathy의 정의).
• MCP와 Agent Skills는 하네스의 핵심 구성 요소다: MCP(Model Context Protocol)는 외부 시스템 연결을, Agent Skills는 반복 작업의 재사용 가능한 지침화를 담당하며, 이 둘이 에이전트의 실행 환경을 구성한다.
• 엔지니어의 역할이 재정의되고 있다: 수동 코딩에서 벗어나 "에이전트가 자율적으로 소프트웨어를 구축할 수 있는 환경 설계"로 초점이 이동하며, 이는 단순한 도구 변화가 아닌 엔지니어링 패러다임의 전환이다.

상세 내용​

하네스 엔지니어링의 정의와 등장 배경​

AI 에이전트를 실제 운영 환경에 투입하면 흥미로운 현상이 발생합니다. 같은 모델을 사용하는데도 프로젝트 A에서는 완벽하게 동작하고, 프로젝트 B에서는 엉뚱한 결과를 내놓습니다. 프롬프트를 아무리 다듬어도 이 격차는 좁혀지지 않습니다. 원인은 대부분 에이전트를 "감싸는 환경"의 차이에 있습니다.

2026년 2월, OpenAI는 놀라운 실험 결과를 발표했습니다. 에이전트를 감싸는 환경만 제대로 구축했을 뿐인데, 수동으로 작성된 코드 없이 AI가 생성한 백만 개 라인에 달하는 프로덕션 소프트웨어를 완성했습니다. 이 결과는 모델 성능이 아닌 "환경 설계"가 에이전트의 실제 성과를 결정한다는 것을 보여줍니다.

**하네스(Harness)**는 AI 에이전트가 안정적으로 작업을 수행할 수 있도록 감싸는 스캐폴딩(scaffolding)이자 피드백 루프가 구축된 전체 환경을 의미합니다. 저장소 구조, CI 설정, 포맷 규칙, 패키지 관리자, 애플리케이션 프레임워크, 프로젝트 지시 사항, 외부 도구 연결, 린터 등 에이전트 바깥에서 동작하는 모든 시스템이 하네스에 포함됩니다. 이는 에이전트가 궤도를 이탈하지 않도록 돕는 기반 인프라 역할을 합니다.

**하네스 엔지니어링(Harness Engineering)**은 엔지니어의 주된 역할이 수동 코드 작성에서 벗어나, 에이전트가 소프트웨어를 자율적으로 구축하고 유지보수할 수 있도록 환경을 설계하고 의도를 명확히 지정하며 피드백 루프를 구축하는 작업으로 재정의된 것을 의미합니다.

프롬프트, 컨텍스트, 하네스의 관계​

세 개념은 포함 관계를 이루며 안쪽부터 바깥쪽으로 확장됩니다:

비유를 들자면, 프롬프트 엔지니어링이 말에게 "오른쪽으로 돌아"라는 음성 명령을 내리는 것이라면, 컨텍스트 엔지니어링은 말에게 지도와 이정표를 보여주는 것이고, 하네스 엔지니어링은 고삐, 안장, 울타리, 도로 정비까지 합쳐서 말 열 마리를 동시에 안전하게 달리게 만드는 전체 설계에 해당합니다.

개념의 진화 과정​

2023~2024: 프롬프트 엔지니어링 시대 ChatGPT에 질문 하나를 던지고 답변 하나를 받는 단순한 구조였습니다. 역할을 부여하고, 단계별로 지시하고, 예시를 넣는 것만으로 원하는 결과를 얻을 수 있었습니다.

2025 중반: 컨텍스트 엔지니어링의 부상 2025년 6월, 전 OpenAI 연구원 안드레이 카르파티(Andrej Karpathy)가 "프롬프트보다 컨텍스트 엔지니어링이 핵심"이라고 언급하면서 패러다임이 전환되었습니다. 단순히 질문을 잘 쓰는 것이 아니라, LLM이 추론할 때 "무엇을 보게 할지" 시스템 수준에서 관리하는 접근이 필요해졌습니다.

LangChain은 이를 컴퓨터에 비유합니다: "LLM은 CPU이고, 컨텍스트 윈도우는 RAM이다. 운영체제가 CPU의 RAM에 무엇을 올릴지 관리하듯, 컨텍스트 엔지니어링도 같은 역할을 한다."

2026년 2월: 하네스 엔지니어링의 등장 AI 에이전트가 본격적으로 운영 환경에 투입되면서 컨텍스트 설계만으로는 해결되지 않는 문제들이 드러났습니다. 팀 컨벤션 위반, 아키텍처 의존성 방향 문제, 병렬 실행 시 파일 충돌, 생성 코드의 점진적 품질 저하 등입니다. 이는 "모델에게 무엇을 보여줄까"가 아니라 "시스템이 무엇을 막고, 측정하고, 고칠 것인가"의 문제입니다.

해시코프(HashiCorp) 공동 창업자 미첼 하시모토(Mitchell Hashimoto)가 2026년 2월 5일 자신의 블로그에서 에이전트의 실수를 방지하는 장치를 쌓아가는 작업을 "하네스 엔지니어링"이라 명명했고, 며칠 뒤 OpenAI도 공식 보고서를 발표하면서 용어가 빠르게 확산되었습니다.

하네스의 핵심 구성 요소​

하네스는 다음과 같은 요소들로 구성됩니다:

1. 저장소 구조와 컨벤션

• 폴더 구조, 네이밍 규칙, 코드 스타일 가이드
• 린터, 포매터 설정
• 아키텍처 가드레일(의존성 방향 검증 등)

2. CI/CD와 자동화 파이프라인

• 자동 테스트, 빌드, 배포 워크플로우
• 에이전트가 생성한 코드에 대한 즉각적인 피드백

3. 외부 도구 연결 (MCP)

• 이슈 트래커, 데이터베이스, API 등 외부 시스템과의 통합
• Model Context Protocol을 통한 표준화된 연결

4. 재사용 가능한 작업 지침 (Agent Skills)

• 반복적인 작업 절차의 문서화
• SKILL.md 형태로 작성된 실행 가능한 가이드

컨텍스트 엔지니어링: 정보 환경 설계​

컨텍스트 엔지니어링은 LLM의 컨텍스트 윈도우에 "무엇을 넣고 무엇을 버릴지" 설계하는 작업입니다. 컨텍스트 윈도우가 수백만 토큰으로 확장되면서 "넣을 수 있는 공간"이 커졌지만, 정보량이 아니라 적합성이 핵심입니다.

컨텍스트 윈도우에 들어갈 수 있는 요소들:

• 시스템 프롬프트: 역할, 제약, 출력 형식
• 대화 이력: 이전 질문과 답변의 흐름
• 검색 문서: RAG로 가져온 관련 문서
• 도구 출력: API 응답, 코드 실행 결과
• 사용자 입력: 현재 질문과 첨부 파일
• 메모리: 장기 기억으로 주입하는 요약 정보

컨텍스트 실패 패턴:

1. Context Poisoning (컨텍스트 오염): 한 번 잘못 들어간 정보가 이후 대화 전체에 걸쳐 사실처럼 전달되는 현상
2. Context Distraction (컨텍스트 산만): 관련 없는 정보가 너무 많아 핵심 근거를 놓치는 현상 (2025년 연구에서 평균 45% 성능 저하)
3. Context Confusion (컨텍스트 혼란): 불필요한 정보가 모델의 판단에 영향을 미치는 현상

프롬프트 vs 컨텍스트 엔지니어링 비교:

고객 문의를 처리하는 CS 챗봇을 예로 들면:

• 프롬프트만 사용: "배송 관련 문의를 하면 조회 방법을 알려줘" → 일반적 응대는 가능하지만 실시간 데이터 접근 불가
• 컨텍스트 설계 추가: 주문 DB와 배송 API를 연결하고, 실시간 상태를 컨텍스트에 주입해 정확한 답변 생성

MCP: 외부 시스템 연결의 표준​

Model Context Protocol(MCP)은 Claude Code 같은 AI 에이전트가 외부 데이터 소스나 도구에 접근할 수 있게 해주는 프로토콜입니다. 전동드릴에 비트를 바꿔 끼우듯, MCP 서버를 연결하면 에이전트가 접근할 수 있는 정보의 범위가 달라집니다.

MCP 서버 연결 방식:

1. HTTP 원격 서버 (권장):

claude mcp add --transport http notion https://mcp.notion.com/mcp

2. 로컬 stdio 서버:

claude mcp add --transport stdio github -- npx -y @modelcontextprotocol/server-github

3. 환경 변수 전달:

claude mcp add --transport stdio --env GITHUB_TOKEN=ghp_xxx github -- npx -y @modelcontextprotocol/server-github

적용 범위(Scope) 설정:

• --scope local: 현재 프로젝트에서만 (기본값)
• --scope project: 팀 공유 (.mcp.json 파일에 저장)
• --scope user: 모든 프로젝트에서 사용

project 스코프를 사용하면 서버 정의는 팀과 공유하되, 인증 토큰은 각 개발자의 로컬 환경에서 관리하는 구조가 됩니다.

Agent Skills: 재사용 가능한 작업 지침​

Agent Skills는 반복되는 작업 절차를 문서화하여 에이전트가 읽고 수행할 수 있게 만드는 방식입니다. Anthropic이 2025년 10월 발표하고 12월에 오픈 스탠다드로 공개한 이 개념은 SKILL.md 파일을 중심으로 작동합니다.

스킬 디렉터리 구조:

code-review/
├── SKILL.md              # 필수: 에이전트가 따를 지침
├── scripts/              # 선택: 실행 스크립트
│   └── run-lint.sh
├── references/           # 선택: 보조 문서
│   └── review-checklist.md
└── assets/               # 선택: 템플릿, 설정 파일
    └── comment-template.md

Progressive Disclosure 원칙: 스킬은 한꺼번에 로드되지 않고 세 단계로 읽힙니다:

• Phase 1: Metadata (~100 tokens) - name, description만 읽음
• Phase 2: Instructions (< 5000 tokens 권장) - SKILL.md 전체 읽음
• Phase 3: Resources (필요한 만큼) - scripts, references 파일 읽음

SKILL.md 작성 예시:

---
name: api-test-runner
description: >-
  API 엔드포인트의 응답 상태, 스키마, 성능을 자동으로 검증한다.
  API 테스트, 엔드포인트 점검, 응답 검증이 필요할 때 사용한다.
---

## 목적
프로덕션 배포 전 API 엔드포인트의 정상 동작을 확인한다.

## 실행 방법
1. `scripts/run-api-test.sh` 실행
2. 실패 시 `references/troubleshooting.md` 참고

중요 작성 포인트:

• description은 WHAT(무엇을 하는지)과 WHEN(언제 쓰는지)을 모두 포함
• 1/2인칭 표현("나는", "당신은") 피하고 3인칭으로 서술
• name은 디렉터리 이름과 일치, 소문자-하이픈만 사용

실무 적용 시나리오​

시나리오: 이슈 기반 코드 수정 자동화

1. 프롬프트만 사용: "ISSUE-1234를 고쳐줘" → 이슈 내용을 모르므로 추가 설명 필요
2. 컨텍스트 추가: GitHub API로 이슈 내용을 가져와 컨텍스트에 주입 → 이슈 내용 파악
3. 하네스 구축:
   • MCP로 GitHub 연결
   • Agent Skill로 "이슈 분석 → 코드 수정 → 테스트 → PR 생성" 워크플로우 정의
   • CI에서 자동 테스트 실행
   • 린터로 코드 스타일 검증

결과: "ISSUE-1234를 고쳐줘"라는 한 문장으로 전체 프로세스가 자동 실행됩니다.

References​

• OpenAI: Harness engineering: leveraging Codex in an agent-first world (2026.02)
• Can Boluk: I Improved 15 LLMs at Coding in One Afternoon (2026.02)
• MadPlay: 프롬프트와 컨텍스트를 넘어, AI 에이전트를 위한 하네스 엔지니어링
• MadPlay: 컨텍스트 엔지니어링: 프롬프트를 넘어 맥락을 설계하는 방법
• MadPlay: Claude Code에서 MCP 서버를 연동하는 방법과 주의할 점
• MadPlay: 에이전트 스킬(Agent Skills)이란 무엇이고, 어떻게 만들까
• Agent Skills Official Specification
• Anthropic: Context Engineering Guide

Claude Code 사용 시 context token을 압축하는 오픈소스 도구인 rtk-ai를 소개합니다. AI 코딩 어시스턴트를 활용할 때 불필요하게 많은 토큰이 소비되는 문제를 해결하여 비용 효율성을 높일 수 있습니다. 특히 대규모 코드베이스를 다루는 Research Engineer들에게 API 비용 절감과 성능 개선에 유용한 도구입니다.

Key Takeaways​

• Context Token 압축: Claude Code와 같은 AI 코딩 어시스턴트 사용 시 전송되는 컨텍스트 토큰을 압축하여 API 비용을 절감할 수 있습니다.
• 비용 최적화: 대규모 코드베이스나 긴 대화 세션에서 누적되는 토큰 비용을 효과적으로 관리할 수 있어, 반복적인 실험이 많은 연구 환경에서 특히 유용합니다.
• 오픈소스 접근성: 오픈소스로 제공되어 자체 환경에 맞게 커스터마이징하거나 내부 시스템과 통합할 수 있습니다.

상세 내용​

rtk-ai란?​

rtk-ai는 Claude Code와 같은 AI 코딩 어시스턴트를 사용할 때 발생하는 context token 소비를 최적화하기 위한 오픈소스 도구입니다. AI 모델에 코드 컨텍스트를 전달할 때, 불필요하거나 중복된 정보를 압축하여 전송함으로써 토큰 사용량을 줄이는 것이 핵심 기능입니다.

왜 Context Token 압축이 필요한가?​

AI Research Engineer들이 Claude Code와 같은 도구를 활용할 때 다음과 같은 상황에서 토큰 비용이 급증할 수 있습니다:

• 대규모 코드베이스: 전체 프로젝트 구조를 컨텍스트로 전달할 때
• 반복적인 쿼리: 비슷한 코드 블록을 여러 번 참조할 때
• 긴 대화 세션: 이전 대화 히스토리가 누적될 때
• 모델 실험: 다양한 프롬프트와 코드 변형을 테스트할 때

이러한 시나리오에서 토큰 압축은 실질적인 비용 절감으로 이어집니다.

활용 시나리오​

연구 코드 개발: 실험적인 모델 구현 시 반복적으로 코드를 수정하고 AI 어시스턴트와 대화하는 과정에서 비용을 절감할 수 있습니다.

코드 리뷰 및 리팩토링: 대규모 코드베이스의 특정 부분을 분석하거나 개선할 때, 필요한 컨텍스트만 효율적으로 전달할 수 있습니다.

문서화 및 설명 생성: 복잡한 연구 코드에 대한 문서를 AI로 생성할 때, 관련 코드만 선별적으로 압축하여 전달할 수 있습니다.

오픈소스의 장점​

rtk-ai가 오픈소스로 제공됨에 따라 다음과 같은 이점이 있습니다:

• 투명성: 토큰 압축 로직을 직접 확인하고 검증할 수 있습니다
• 커스터마이징: 특정 프로젝트나 팀의 니즈에 맞게 수정 가능합니다
• 통합 용이성: 기존 개발 워크플로우나 CI/CD 파이프라인에 통합할 수 있습니다
• 커뮤니티 기여: 개선 사항을 공유하고 다른 사용자들의 피드백을 받을 수 있습니다

도입 시 고려사항​

rtk-ai를 프로젝트에 도입할 때는 다음을 고려해야 합니다:

• 압축으로 인해 손실되는 컨텍스트 정보가 있는지 확인
• 특정 코드 패턴이나 프로젝트 구조에 최적화된 압축 설정
• 팀원들의 워크플로우와의 호환성
• 압축 효과와 실제 비용 절감 효과 측정

References​

• rtk-ai (오픈소스 프로젝트) - 원본 문서 참조

AI 에이전트 생태계에서 파일시스템이 '영속적 기억 장치'로 재조명받고 있습니다. LLM의 컨텍스트 윈도우는 일시적인 화이트보드에 불과하지만, CLAUDE.md 같은 파일 기반 접근은 에이전트에게 장기 기억과 정체성을 제공합니다. Anthropic의 Agent Skills(SKILL.md) 포맷이 Microsoft, OpenAI, GitHub 등에 채택되며 사실상 표준으로 자리잡았고, 파일 포맷이 곧 API가 되는 '조율 없는 상호운용성' 시대가 열리고 있습니다. 다만 ETH Zürich 연구에 따르면 과도한 컨텍스트 파일은 오히려 성능을 저하시키므로, 최소한의 필수 요구사항만 담아야 합니다.

Key Takeaways​

• 파일시스템은 LLM의 일시적 컨텍스트 윈도우를 보완하는 가장 단순한 영속적 저장소입니다. Claude Code, Cursor 등 주요 AI 코딩 도구들이 파일 기반 컨텍스트 관리를 핵심 기능으로 채택했습니다.
• SKILL.md 포맷이 AI 에이전트 간 사실상 표준으로 부상하며, Microsoft, OpenAI, GitHub, Cursor가 Anthropic의 Agent Skills 포맷을 채택해 도구 간 컨텍스트 이식성을 확보했습니다.
• 과도한 컨텍스트는 독이 됩니다. ETH Zürich 연구 결과, 장황한 컨텍스트 파일은 태스크 성공률을 낮추고 추론 비용을 20% 이상 증가시킵니다. 최소한의 핵심 요구사항만 기술해야 합니다.
• 파일 포맷이 곧 API가 되는 시대: 마크다운 기반 스킬 파일은 특정 앱에 종속되지 않고 이동·조합·감사가 가능하며, MCP 서버나 플러그인 마켓플레이스 없이도 '조율 없는 상호운용성'을 달성합니다.
• LlamaIndex의 Jerry Liu가 제안한 원칙: 수백 개 도구를 가진 에이전트 하나보다, 파일시스템과 5~10개 핵심 도구만으로 구성된 에이전트가 더 범용적이고 효과적일 수 있습니다.

상세 내용​

왜 지금 파일시스템인가?​

AI 에이전트 생태계에서 파일시스템이 다시 주목받고 있습니다. LlamaIndex는 "Files Are All You Need"를 발표했고, LangChain은 에이전트의 파일시스템 기반 컨텍스트 엔지니어링을 다뤘으며, Oracle조차 에이전트 메모리 관리에서 파일시스템과 데이터베이스를 비교하는 글을 게시했습니다.

이 움직임의 핵심은 데이터베이스와는 다른 지속적 맥락 관리 수단으로서 파일시스템의 재발견입니다. Andrej Karpathy는 Claude Code가 성공한 이유를 "사용자의 컴퓨터·환경·데이터·컨텍스트 위에서 직접 실행되기 때문"이라고 지적하며, OpenAI의 클라우드 컨테이너 중심 접근이 잘못된 방향이었다고 평가했습니다.

실제로 Anthropic은 CLI 도구인 Claude Code가 수익의 상당 부분을 견인하면서 흑자에 근접하고 있으며, 현재 코딩 에이전트가 실질적 AI 활용 사례의 대부분을 차지하고 있습니다.

컨텍스트 윈도우의 한계: 화이트보드 vs 영속적 기억​

LLM의 컨텍스트 윈도우는 흔히 '기억'으로 오해되지만, 실제로는 계속 지워지는 화이트보드에 가깝습니다. 인간의 기억은 장기 저장, 선택적 회상, 불필요한 정보 망각 기능을 포함하지만, LLM은 이런 기능이 없습니다.

Claude Code를 사용하다 보면 "context left until auto-compact" 알림을 마주하게 됩니다. 이때 에이전트가 축적한 코드베이스, 선호도, 결정 사항 등의 컨텍스트가 압축되거나 소실됩니다. 파일시스템은 이를 가장 단순한 방식으로 해결합니다: 기록을 파일에 쓰고, 필요할 때 다시 읽는 것입니다.

실무에서 활용되는 예시:

• CLAUDE.md: 프로젝트에 대한 영속적 컨텍스트 제공
• Cursor의 채팅 히스토리: 과거 대화를 검색 가능한 파일로 저장
• aboutme.md: 개발자의 선호도, 기술 스택, 작업 스타일을 담은 이동 가능한 신원 기술자. API 조율 없이 앱 간 이동 가능

ETH Zürich 연구: 컨텍스트 파일의 역설​

ETH Zürich의 최근 논문은 리포지토리 수준의 컨텍스트 파일이 실제로 코딩 에이전트의 태스크 완수에 도움이 되는지 평가했습니다. 결과는 반직관적이었습니다.

주요 발견:

• 여러 에이전트와 모델에 걸쳐 컨텍스트 파일이 태스크 성공률을 오히려 낮춤
• 추론 비용은 20% 이상 증가
• 컨텍스트 파일을 받은 에이전트는 더 넓게 탐색하고, 더 많은 테스트를 실행하고, 더 많은 파일을 순회했지만, 정작 수정이 필요한 코드에 도달하는 것은 지연

이 현상의 원인은 파일이 에이전트가 지나치게 진지하게 따르는 체크리스트처럼 작동했기 때문입니다. 논문의 결론은 "컨텍스트 파일을 쓰지 말라"가 아니라, **"불필요한 요구사항이 태스크를 어렵게 만들며, 컨텍스트 파일은 최소 요구사항만 기술해야 한다"**는 것입니다.

문제는 파일시스템의 영속 계층 자체가 아니라, CLAUDE.md를 2,000단어짜리 온보딩 문서처럼 작성하는 관행입니다.

파일 포맷이 곧 API: 표준화의 여정​

현재 CLAUDE.md, AGENTS.md, copilot-instructions.md, .cursorrules 등이 공존하며, 에이전트에 영속적 파일시스템 기반 컨텍스트가 필요하다는 점은 합의되었으나 파일 이름과 내용 형식은 아직 미합의 상태입니다.

Anthropic의 Agent Skills: 사실상 표준의 등장

Anthropic은 Agent Skills를 오픈 표준으로 발표하며 SKILL.md 포맷을 제안했습니다. 이는 빠르게 채택되어:

• Microsoft, OpenAI, Atlassian, GitHub, Cursor가 공식 채택
• Claude Code용으로 작성한 스킬이 Codex, Copilot에서도 작동
• 파일 포맷이 곧 API가 되는 패러다임 실현

Dan Abramov의 소셜 파일시스템 제안

Dan Abramov는 AT Protocol 기반 소셜 파일시스템을 제안하며 핵심 설계 원칙을 제시했습니다:

• 사용자 데이터를 개인 리포지토리 내 파일로 취급
• 앱들이 "포스트가 무엇인지" 합의할 필요 없이 도메인 네임 기반 네임스페이스로 충돌 방지
• 모든 앱의 데이터베이스는 파생 데이터, 즉 모든 사용자 폴더의 캐시된 구체화 뷰

실용적 사례: NanoClaw와 스킬 기반 아키텍처​

NanoClaw는 경량 개인 AI 어시스턴트 프레임워크로, 기능 대신 스킬 모델을 채택했습니다:

• Telegram 지원이 필요하면 Telegram 모듈이 아닌 /add-telegram 스킬(마크다운 파일)이 Claude Code에 통합 방법을 가르침
• 스킬은 파일이므로 이동 가능하고, 감사 가능하며, 조합 가능
• MCP 서버나 플러그인 마켓플레이스 불필요

이것이 조율 없는 상호운용성(interoperability without coordination)입니다. 두 앱이 마크다운을 읽을 수 있으면 컨텍스트를 공유할 수 있습니다.

LlamaIndex의 미니멀리즘: 도구보다 파일시스템​

LlamaIndex의 Jerry Liu는 흥미로운 주장을 펼쳤습니다:

"수백 개 도구를 가진 에이전트 하나 대신, 파일시스템과 5~10개 도구만으로 100개 이상의 MCP 도구를 가진 에이전트보다 더 범용적일 수 있다."

이는 에이전트 설계에서 복잡도를 줄이고 기본 인터페이스에 집중하라는 메시지입니다. 파일시스템은:

• 특정 앱에 종속되지 않음
• AI 에이전트 시대에 도구 간 전환, 워크플로 결합, 연속성 유지를 가능하게 하는 개방형 인터페이스

Archil과 POSIX 파일시스템​

Archil은 "에이전트가 POSIX 파일시스템을 원하기 때문에" 클라우드 볼륨을 구축 중이라고 밝혔습니다. 이는 에이전트가 표준 파일시스템 API를 통해 작동할 때 가장 효율적이며, 클라우드 환경에서도 이런 접근이 필요함을 시사합니다.

References​

• 파일시스템이 주목받는 이유 - GeekNews
• 원문: Why Files Are Having a Moment
• Anthropic Agent Skills Documentation
• LlamaIndex: Files Are All You Need
• ETH Zürich: Context Files in Code Agents Research
• Dan Abramov: AT Protocol Social Filesystem

LLM Post Training은 사전학습된 언어 모델을 실제 사용 가능한 AI 어시스턴트로 변환하는 핵심 과정입니다. Supervised Fine-Tuning(SFT)으로 instruction-following 능력을 학습한 후, Reinforcement Learning from Human Feedback(RLHF)를 통해 인간의 선호도에 맞춰 모델을 정렬합니다. 최근에는 Direct Preference Optimization(DPO) 같은 방법으로 RL 없이도 효과적인 선호도 학습이 가능해졌으며, Rejection Sampling과 iterative training을 통해 지속적인 성능 개선을 달성할 수 있습니다.

Key Takeaways​

• Post Training은 3단계 프로세스: SFT → Reward Modeling → RL/DPO로 구성되며, 각 단계는 모델의 유용성(helpfulness)과 무해성(harmlessness)을 점진적으로 개선
• DPO는 RL의 실용적 대안: Reward model과 복잡한 RL 파이프라인 없이 preference pair 데이터만으로 직접 최적화 가능하여 구현 및 안정성 측면에서 유리
• Rejection Sampling으로 데이터 품질 향상: 모델이 생성한 여러 샘플 중 높은 reward를 받은 응답만 선별하여 SFT 데이터셋을 강화하는 self-improvement 기법
• Iterative training이 핵심: SFT와 RL/DPO를 반복적으로 수행하며, 매 iteration마다 새로운 데이터로 학습하여 모델의 지속적인 성능 향상 달성
• 실무 적용 시 trade-off 고려: Helpfulness와 harmlessness 간의 균형, 학습 안정성과 성능 간의 trade-off를 도메인 특성에 맞게 조정 필요

상세 내용​

Post Training의 전체 구조​

LLM Post Training은 사전학습(Pre-training)된 base model을 실제 사용자와 상호작용할 수 있는 대화형 AI로 변환하는 과정입니다. 사전학습 단계에서는 대규모 텍스트 코퍼스로 next-token prediction을 학습하지만, 이것만으로는 사용자의 지시를 따르거나 안전한 응답을 생성하기 어렵습니다.

Post Training은 크게 세 가지 주요 단계로 구성됩니다:

1. Supervised Fine-Tuning (SFT): Instruction-response 쌍으로 모델을 fine-tuning
2. Reward Modeling: 인간의 선호도를 학습하는 reward model 구축
3. Reinforcement Learning (RL) / Direct Preference Optimization (DPO): 선호도에 맞춰 모델 정렬

Supervised Fine-Tuning (SFT)​

SFT는 Post Training의 첫 번째 단계로, 고품질의 instruction-response 데이터셋을 사용하여 모델이 사용자의 요청을 이해하고 적절히 응답하는 능력을 학습합니다.

핵심 특징:

• 기존의 일반적인 supervised learning과 동일한 방식으로 학습
• 입력(instruction)과 출력(response) 쌍으로 구성된 데이터 필요
• 모델이 instruction-following 능력을 획득하는 기초 단계

SFT 데이터의 품질이 최종 모델의 성능을 크게 좌우합니다. 따라서 다양한 도메인과 태스크를 포괄하면서도 높은 품질을 유지하는 데이터셋 구축이 중요합니다.

Reward Model Training​

Reward Model은 인간의 선호도를 수치화하여 모델 응답의 품질을 평가하는 역할을 합니다. RLHF(Reinforcement Learning from Human Feedback)의 핵심 구성요소입니다.

학습 방식:

• 동일한 입력에 대해 여러 응답을 생성하고, 인간 평가자가 선호도를 매깁니다
• Preference pair 형태의 데이터: (prompt, chosen_response, rejected_response)
• Bradley-Terry 모델을 기반으로 ranking loss를 최소화하도록 학습

Reward Model은 이후 RL 단계에서 모델의 행동을 guide하는 신호로 사용되며, 인간의 피드백을 효율적으로 스케일업할 수 있게 해줍니다.

Reinforcement Learning from Human Feedback (RLHF)​

RLHF는 Reward Model을 활용하여 LLM을 인간의 선호도에 맞게 최적화하는 단계입니다. 주로 Proximal Policy Optimization (PPO) 알고리즘이 사용됩니다.

학습 프로세스:

1. SFT 모델에서 prompt에 대한 응답 생성
2. Reward Model이 생성된 응답의 점수를 평가
3. PPO를 통해 높은 reward를 받는 방향으로 policy 업데이트
4. KL divergence penalty를 추가하여 원본 SFT 모델로부터 너무 멀어지지 않도록 규제

장단점:

• 장점: 인간의 복잡한 선호도를 효과적으로 학습 가능
• 단점: 학습이 불안정하고, reward model, reference model, policy model 등 여러 모델을 동시에 관리해야 하는 복잡성

Direct Preference Optimization (DPO)​

![](https://prod-files-secure.s3.us-west-2.amazonaws.com/bb84b169-cb88-81fc-90c3-00032f05f905/75298940-c149-426f-81e4-cf709b8b691d/image.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=ASIAZI2LB4663GPPEBMS%2F20260325%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20260325T065709Z&X-Amz-Expires=3600&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEN%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLXdlc3QtMiJIMEYCIQDZrbugPUCbzgt%2FOXDqMwyPEqw4l91MjfgrjlbZGwwVXgIhAK%2Bv%2Bowqi17EMdRgWEvO%2B3PZIK2wacd%2B484IB8H5InLSKogECKf%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEQABoMNjM3NDIzMTgzODA1IgzgVVeN9sn5VNRnpCcq3ANLPfIq5vvCnEMvmXjBH0xPG%2BdtFlb3BwYyNy9S1lWVhKBH%2FwUVnoToCFAbapCtJuzLJAVg%2Bc%2Fg48bDqjjdH6otZKAyqCSFQsIn6LXfV2OBJ2dgWUDjKQIW%2FsYQPhiGmFXfyKfPAInDlUAnjGio%2FyAUTB0YoekjhKU2pJSZfsCSv1fh7RbvrCgyye231Kdf3eet%2B7oKAUPJICqpfgTOxNHz8zXhNgwIMFnQGw1ygsWzxiPcd22vot1oa5QoOt9qdcVXhh9kvSHzlf%2ByFGoQ9fP%2Fy1csOeNVw05UHv%2FoajCTRYjUFAW86EzyGDdboqhSkK2CHWDZFfDgMjGunIffzGpkTGDl7%2BjrMbaNj1Syxsq8kafa6LQFaRxCJt8MBE47moH0mZATK%2FQiVvreFL5bQK9bshsO1jbhRT3zPyM3KUkpBfW9XfI0qCjbQj81hZ4n8spJ%2BE1MUvCV8K3dCzyaQi2h21EpuiRVBWlzxu34TRX5TBz9qrTnXnukzR8vS0M59Smv4Bhg%2BnTEujeeBEcYWFgF4sD8ITvusPpSsyGnoPStyWizCJh6kyKWHS6TvoKx%2FvDWbJajZbFlTz0nOnvTVTwwqWTnok8tzWRunkDag59Y54mfU1iVWkijj9CY%2FDC7%2FY3OBjqkAbP%2F2ef6A8887gUbu%2F80lGRhpzTHeaqoAq0Qw5F5YZCbx11ADz4cGXWG%2BbAF9tcmZG0i4eMiQU5CjnRNP1yjYUblP%2Bp2cLzcZhsYpMM%2FM08X%2F1sYR2LyanJsfczKYLpZxR%2

AWS EC2에서 GPU 인스턴스를 프로비저닝하는 실무 가이드입니다. P/G/Inf 시리즈 등 인스턴스 타입 선택부터 AMI 설정, 네트워크 구성, 스토리지 최적화까지 GPU 워크로드 배포 시 필수적으로 고려해야 할 사항들을 단계별로 다룹니다. 특히 리전별 가용성, Deep Learning AMI 활용, 캐퍼시티 블록 구매 시 주의사항, 인스턴스 스토어의 임시성 등 실제 운영에서 마주칠 수 있는 함정들을 강조합니다.

Key Takeaways​

• 인스턴스 타입 선택의 중요성: P 시리즈(학습용), G 시리즈(추론/렌더링), Inf 시리즈(추론 최적화)를 목적에 맞게 선택해야 하며, 리전별 가용성 사전 확인 필수 (예: 서울 리전에서는 H100 인스턴스 불가)
• Deep Learning AMI 활용: NVIDIA 드라이버, CUDA, cuDNN이 사전 설치된 AMI를 사용하면 초기 설정 시간을 대폭 절약 가능
• 캐퍼시티 블록 구매 주의: GPU 경쟁 과열 시 1시간 단위 즉시 예약이며 환불 불가이므로 신중한 검토 필요
• 스토리지 전략: gp3/io2 EBS를 기본으로 사용하되, 인스턴스 스토어(NVMe)는 인스턴스 중지 시 데이터 손실되므로 임시 데이터(캐시, 버퍼)에만 활용
• 자원 최소화 원칙: GPU 인스턴스는 고비용 리소스이므로 사용 전 리뷰 프로세스를 거치고, 불필요한 가동 시간 최소화 필요

상세 내용​

GPU 리소스 사용 승인 프로세스​

GPU 인스턴스는 높은 비용이 발생하는 리소스이므로, 사용 전 내부 리뷰 프로세스를 통해 적절한 타입과 용량을 검증받아야 합니다. 이는 불필요한 자원 낭비를 방지하고 비용 효율성을 확보하기 위한 필수 단계입니다.

GPU 인스턴스 타입 이해​

AWS는 용도에 따라 구분된 GPU 인스턴스 패밀리를 제공합니다:

• P 시리즈 (P3, P4, P5): 머신러닝 학습 및 고성능 컴퓨팅(HPC)에 최적화. 대규모 모델 학습이나 분산 학습 워크로드에 적합
• G 시리즈 (G4dn, G5, G6): 그래픽 렌더링, 게임 스트리밍, ML 추론 등 그래픽 집약적 작업에 특화
• Inf 시리즈: Amazon 자체 Inferentia 칩을 사용한 ML 추론 최적화 인스턴스. 비용 대비 추론 성능이 우수

리전별 가용성 사전 확인​

모든 AWS 리전에서 모든 GPU 인스턴스 타입을 사용할 수 있는 것은 아닙니다. 특히 최신 GPU를 탑재한 인스턴스의 경우 제한적입니다.

중요 예시: ap-northeast-2(서울) 리전에서는 H100 1EA 인스턴스(p5.4xlarge) 사용이 불가능합니다. 프로젝트 시작 전 목표 리전에서 필요한 인스턴스 타입의 가용성을 반드시 확인해야 합니다.

AMI 선택 전략​

GPU 워크로드를 위한 인스턴스는 적절한 NVIDIA 드라이버, CUDA 툴킷, cuDNN 등이 사전 설치된 AMI를 사용하는 것이 권장됩니다.

권장 AMI:

• Deep Learning AMI (Ubuntu/Amazon Linux): NVIDIA 드라이버, CUDA, cuDNN이 사전 설치되어 있어 즉시 딥러닝 프레임워크 사용 가능
• AWS Marketplace의 GPU 최적화 AMI: PyTorch, TensorFlow 등 특정 프레임워크가 미리 설정된 이미지

일반 AMI를 선택하는 경우 NVIDIA 드라이버를 수동으로 설치해야 하므로 초기 설정 시간이 증가합니다.

인스턴스 생성 프로세스​

1. 인스턴스 타입 및 용량 결정​

GPU 리소스 검토 과정에서 승인받은 내역을 바탕으로 적절한 인스턴스 유형, VRAM 용량을 선택합니다.

![인스턴스 설정 4](https://prod-files-secure.s3.us-west-2.amazonaws.com/bb84b169-cb88-81fc-90c3-00032f05f905/576f9463-ab24-45ae-a26b-081dc9018a46/image.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=ASIAZI2LB466XOL2RWTI%2F20260325%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20260325T064504Z&X-Amz-Expires=3600&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEN%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLXdlc3QtMiJHMEUCIQDqPcWww2%2FpQ%2Be1RS0GoLH2PqRGairWhkf5VAqDzJjrDgIgDFxY3LBTm2DChRO06qiqQORa%2BTwwwAGB4Irhokw2nnkqiAQIp%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FARAAGgw2Mzc0MjMxODM4MDUiDHWk54hH51hF8rmCtCrcA8SybE%2Bcehb2%2Bxjqq9d6ZrsWnzwPaWhd310kPdYge9qDhfuTquJLhuwQcydhVE3LkJeo8LjYfrE1noL6PPxX5KdYBS2OsUe822kgvtmslCvNWwl897%2Bdlw6A%2FKYpXBadSwsUbtdCmDM2CWy9UnqSPvc1MVuX26RJ7grJzCZ3FwJ%2BN0RioHjzyyQpgHNnBjzCOc5T0P639oKy%2F5%2B9vNAYW4BZqW5X5U50nf%2BhCk8%2F0It2nYhZm2fxi0jHp%2BybPeI2xY1lrcGM%2BB4M1dljm7C%2BdWI2CLLDe1%2FMwhQo5GX10j1ALiHiEBNN8aMePUlAek4CtbmJ7MxtRN1cPhkFfO7pqB1JLKI5PHvDlycWmHih%2BWftE6eJ3Es5DmY8zJ2GlrL6llNGp%2FujdYfYXfszKydwMys5s5FeurJ6IfhXC%2F24QdVJQnLjVJF6SSC29%2B1tF5Iy1gwSQr4K2bgHNkW6qBK%2FNG32gESCN9X6e2adDdyxh3Pe%2B99nKzDAZP9R72XRiOT2GYrwf9tmnGynn3cIQSn2Oc3f16V1srluXAUxx19tmZk39KFjMccQGUO37wfn5dfg6qcm%2BEHlqr3sS7aVdWgrWLKnx%2BN5tkREfAA0DRwnHAXJbwSgcbwIXb7iPkukMLv9jc4GOqUB%2BeM2AI%2BAgNC%2FLYyXnjFoaBm1dUwt%2FtgqITp8E8GcmhAxjiHbWr%2FBsOJShvWO2evdkrG8rq8Wo1o1kFTQBrkPgJGsf%2BSJSvM%2BSZvU1f9XQXFeR%2Bs%2B2oNARyVNv3RFxSbvy9pc84q8KCpgKOIL%2FidQ%2FWiTrZ7MK8ddm6oGiwh%2BheLj3BOrdd9mImjLSbeJBeG%2BcpT38ig

AI Agent 시스템은 메신저 기반의 접근성(Manus Agents)부터 로컬 학습 시스템(PAI)까지 빠르게 진화 중입니다. 특히 메신저 환경에서 QR 코드 스캔만으로 동작하는 Manus Agents는 설정 복잡도를 제거하며 대중화를 노리고, PAI는 로컬 데이터 기반으로 사용자를 지속적으로 학습하는 개인 AI 비서를 제공합니다. 하지만 AI 코딩 도구 연구 결과는 상반됩니다 - 56% 생산성 향상과 19% 저하가 공존하며, 체감과 실제 성능의 괴리가 존재합니다. Agent 시스템의 실질적 효과는 작업 유형, 사용자 숙련도, 측정 방식에 따라 크게 달라집니다.

Key Takeaways​

• 메신저 기반 Agent의 전략적 전환: Manus Agents는 복잡한 설정 없이 QR 코드로 연결되며, 지속 메모리를 통해 사용자 스타일·선호도를 장기 학습합니다. 개발자 도구가 아닌 일상 커뮤니케이션 레이어로 AI를 확장하는 접근입니다.
• 생산성 측정의 복잡성: AI 코딩 도구는 실제 코딩 시간을 단축시키지만, 프롬프트 작성·검토·응답 대기 등 새로운 오버헤드를 생성합니다. 체감 생산성과 실측 데이터는 일치하지 않으며, 커밋 수 증가가 품질 향상을 의미하지 않습니다.
• 초급 개발자에게 더 큰 효과: 여러 연구에서 AI 도구는 초급 개발자의 속도를 더 크게 향상시킵니다. 이는 "AI가 있으니 주니어 채용 불필요"가 아니라 "주니어+AI 조합이 최대 효과"를 의미합니다.
• 로컬 우선 개인화 시스템: PAI는 모든 대화·작업을 로컬에 저장하는 3계층 메모리 구조(Hot/Warm/Cold)로 프라이버시를 보호하며, 모듈러 스킬 팩 시스템으로 필요한 기능만 선택적으로 확장할 수 있습니다.
• 속도보다 지속 가능성: Continuous Delivery 관점에서 AI 도구의 가치는 단순 속도가 아니라 "안전하게 빠르게 지속 가능하게" 전달하는 능력에 있습니다. 코드 리뷰·품질 단계 생략은 장기적 기술 부채를 초래합니다.

상세 내용​

메신저 기반 AI Agent의 부상: Manus Agents​

실리콘밸리를 중심으로 AI Agent 경쟁이 격화되고 있습니다. Meta가 약 20억 달러에 인수한 Manus는 복잡한 설정을 제거하고 메신저 환경에서 작동하는 개인 AI Agent를 제시합니다.

기존 시스템의 한계와 Manus의 차별점​

OpenClaw와 같은 기존 개인 AI Agent는 강력한 기능을 제공하지만, 설정 과정의 복잡성과 유지 관리 부담이 진입 장벽으로 작용했습니다. Manus Agents는 이를 다음과 같이 해결합니다:

초기에는 Telegram을 통해 출시되며, 향후 WhatsApp, LINE, Slack, Discord, Messenger로 확장될 예정입니다. Windows 및 Mac용 네이티브 애플리케이션도 준비 중입니다.

핵심 기술 특징​

1. 지속 메모리 기반 개인화 시스템

Manus Agents는 단발성 질의응답이 아닌 장기적 컨텍스트 유지를 핵심으로 합니다. 시스템은 사용자의 글쓰기 스타일, 어조, 개인 선호도를 지속적으로 학습하며, 이렇게 학습된 패턴은 이후 새로운 작업에 자동으로 반영됩니다.

2. 멀티스텝 작업 자동 실행

사용자가 "발표 자료 생성" 또는 "웹사이트 프로그래밍"과 같은 메시지를 보내면, AI는 내부적으로 작업 단계를 계획하고 실행합니다. 각 단계를 수동으로 지시할 필요가 없습니다.

3. 외부 서비스 연동

Gmail, Google Calendar, Notion 등 외부 서비스에 접근하여 메시지 맥락을 분석해 필요한 작업을 자동으로 수행합니다. 사용자는 별도의 파일 관리나 API 설정을 직접 다루지 않아도 됩니다.

보안 설계와 접근 권한​

Manus는 프라이버시 우려를 최소화하기 위해 제한적 접근 권한을 설계했습니다:

• AI는 자신의 채팅 기록 내 직접 메시지만 읽음
• 다른 대화, 그룹, 연락처 목록에는 접근 불가

사용자 커스터마이징 옵션​

모델 선택:

• Manus 1.6 Max: 심층 사고 중심
• Manus 1.6 Lite: 빠른 작업 처리

응답 스타일:

• 간결한 스타일
• 구조화된 스타일
• 대화형 스타일

또한 Telegram 내에서 음성 메시지(자동 전사 및 의도 분석), 이미지(내용 해석), 문서 파일(즉시 분석 및 작업 수행) 등 멀티미디어를 직접 처리합니다.

로컬 우선 개인 AI 인프라: PAI​

PAI(Personal AI Infrastructure)는 보안 전문가이자 AI 연구자인 Daniel Miessler가 개발한 오픈소스 개인 AI 인프라입니다. GitHub에서 7,300개 이상의 스타를 보유하고 있으며, MIT 라이선스로 무료 공개되어 있습니다.

PAI의 핵심 차별점: "AI가 나를 학습한다"​

일반 AI 챗봇과 달리 PAI는 모든 대화와 작업 결과를 로컬에 저장하고, 이를 통해 사용자의 선호도, 작업 스타일, 프로젝트 맥락을 지속적으로 학습합니다. 새로운 대화를 시작할 때마다 배경을 처음부터 설명할 필요가 없어집니다.

3계층 메모리 시스템​

이 구조 덕분에 다음이 가능합니다:

• "지난주에 우리가 만들었던 파이썬 함수를 다시 보여줘" → 로컬 저장소에서 즉시 검색
• "내가 선호하는 코드 스타일이 뭐지?" → 과거 작업 패턴 분석으로 자동 파악
• "이 프로젝트에서 우리가 어떤 의사결정을 했었지?" → 모든 의사결정 기록 검색

모듈러 스킬 팩 시스템​

PAI는 필요한 기능을 선택적으로 추가/제거할 수 있는 스킬 팩을 제공합니다:

기타 핵심 기능​

• 훅 시스템: 작업 전후에 자동 실행되는 사용자 정의 스크립트 (예: 코드 작성 전 보안 검사, 완료 후 자동 커밋)
• 알고리즘: 관찰→생각→계획→실행→검증→학습의 7단계 문제 해결 프로세스
• 음성 알림: ElevenLabs TTS 연동으로 작업 진행 상황을 음성으로 안내

기술 요구사항​

• 운영체제: macOS, Linux (WSL2 포함), Windows(WSL2)
• Node.js: v18 이상
• 메모리: 최소 8GB RAM (16GB 권장)
• 디스크: 최소 2GB 여유 공간
• Claude Code: Anthropic AI 계정 및 설치 필요

PAI는 TypeScript로 개발되었으며, 2025년 9월 공개 이후 일일 평균 46.8개의 스타를 기록하며 빠르게 성장 중입니다.

AI 코딩 도구의 생산성 논쟁: 56% vs 19%​

AI 코딩 도구의 실제 효과에 대해 상반된 연구 결과가 제시되고 있습니다.

56% 빨라졌다: GitHub 협업 실험 (2023)​

Microsoft Research, GitHub, MIT의 협업 실험에서 개발자에게 JavaScript로 HTTP 서버를 구현하는 과제를 부여했습니다:

• AI 사용 그룹: 평균 71분
• 비사용 그룹: 평균 161분
• 결과: 약 55.8% 더 빠름

특히 초급 개발자에게서 속도 향상이 두드러졌으며, 과제 성공률은 두 그룹 간 큰 차이가 없었습니다.

연구의 한계:

• 도구 공급사가 실험 설계에 참여
• 통제된 환경의 단일 과제 중심
• 실제 복잡한 프로젝트와는 상황이 다름

19% 느려졌다: METR의 현실 프로젝트 분석 (2025)​

METR 연구는 실제 오픈소스 프로젝트에서 16명의 개발자가 수행한 246개 작업을 분석했습니다:

• 전체 작업 완료 시간: 평균 19% 증가

세부 변화:

• ✅ 실제 코딩 시간 감소
• ✅ 검색, 테스트, 디버깅 시간 감소
• ❌ 새로운 작업 유형 증가: AI 출력 검토, 프롬프트 작성, 응답 대기
• ❌ 오버헤드 시간 증가

인지 편향의 함정: 흥미롭게도 개발자들은 실제로는 19% 느려졌음에도 "AI가 시간을 절약해줬다"고 체감했습니다. 이는 멀티태스킹이 생산성을 높인다고 믿었던 과거의 인지 편향과 유사합니다.

Multitudes 연구의 복잡성 (2025)​

10개월간의 데이터 분석 결과:

• 코드 변경 수 증가
• 근무 시간 외 커밋도 함께 증가

이는 두 가지 해석이 가능합니다:

1. AI 덕분에 처리량이 증가했다
2. 안정성을 희생하면서 속도를 올렸다

야간 커밋 증가는 새로운 기능 개발이 아니라 오류 수정이나 불안정성 대응일 가능성도 있습니다. 단순히 커밋 수 증가 = 생산성 증가로 볼 수 없다는 점을 시사합니다.

초급 개발자에게 더 큰 효과​

여러 연구에서 반복적으로 나타나는 패턴:

• AI 코딩 도구는 초급 개발자에게 더 큰 효과를 제공
• 숙련 개발자에게는 상대적으로 효과가 제한적

장기적 인재 구조 영향:

일부 조직은 "AI가 있으니 주니어를 채용하지 않아도 된다"는 판단을 내리고 있습니다. 그러나 연구 결과는 오히려 주니어 개발자가 AI와 함께 사용할 때 가장 큰 속도 향상을 보인다고 말합니다.

단기적 비용 절감이 장기적 인재 부족으로 이어질 가능성이 있으며, 이는 닷컴 버블 이후 주니어 채용 중단으로 숙련 개발자 부족 현상이 발생했던 사례와 유사할 수 있습니다.

속도보다 지속 가능성: Continuous Delivery의 관점​

일부에서는 AI로 생성된 코드를 빠르게 배포하기 위해 코드 리뷰나 품질 단계를 줄이자는 주장도 제기됩니다. "속도가 곧 경쟁력"이라는 논리입니다.

그러나 **지속적 전달(Continuous Delivery)**의 관점은 다릅니다. 핵심은 단순한 속도가 아니라:

1. 안전하게 빠르게
2. 지속 가능하게 빠르게
3. 품질을 유지하며 빠르게

코드 리뷰와 품질 단계 생략은:

• 단기적으로는 배포 속도를 높일 수 있음
• 장기적으로는 기술 부채와 유지보수 비용 증가
• 시스템 안정성 저하와 보안 취약점 증가

생산성은 체감이 아니라 데이터로 판단해야 하며, AI 도구의 가치는 장기적 코드 품질과 팀 역량 유지 여부로 측정되어야 합니다.

AI Agent 시스템의 진화 방향​

현재 AI Agent 시스템은 다음과 같은 방향으로 진화하고 있습니다:

1. 접근성 향상

• 복잡한 설정 제거 (QR 코드, 메신저 기반)
• 전문 개발자가 아닌 일반 사용자 타깃

2. 맥락 지속성 강화

• 지속 메모리 시스템
• 로컬 데이터 기반 학습
• 장기적 사용자 이해

3. 플랫폼 확장

• 단일 환경에서 다중 플랫폼으로 (Telegram → WhatsApp, Slack 등)
• 메신저와 업무용 소프트웨어의 경계 약화

4. 실행 능력 확대

• 대화형 응답에서 실제 소프트웨어 제어로
• 멀티스텝 작업 자동화
• 외부 서비스 통합

5. 프라이버시 우선 설계

• 로컬 데이터 저장
• 제한적 접근 권한
• 사용자 통제 강화

References​

• 메신저 안에서 완성하는 개인 AI 에이전트 경쟁: Manus Agents와 OpenClaw의 전략 분석
• AI 코딩 도구는 개발자를 56% 빠르게 만들까, 19% 느리게 만들까? 상반된 연구 결과로 본 생산성의 진실
• 완전 무료! GitHub 9k! 나를 학습하는 PAI로 개인 AI 비서 구축하기
• PAI GitHub Repository

RAG에서 AI Agent로 빠르게 전환되는 시점에서, 실무자는 LLM·RAG·Agent의 본질적 개념을 정확히 이해해야 한다. Gen.AI 서비스는 기술·BM·아키텍처 관점에서 다층적으로 분류되며, 기존 서비스 대비 복잡도가 높다. 효과적인 서비스 구축을 위해서는 서비스를 명확히 정의하고, Product·Data·RAG 팀이 각자의 전문성을 기반으로 역할을 분업화해야 한다.

Key Takeaways​

• 기술 트렌드 이해: RAG는 이미 정착되었으나 Agent 중심으로 빠르게 전환 중이며, 실무자는 각 기술의 본질적 차이와 적용 시점을 명확히 구분해야 한다.
• 서비스 분류 체계: Gen.AI 서비스는 기술 관점(Content-Centric, Conversational, Automation 등 6가지)과 BM 관점(B2B/B2C × SaaS/IaaS/PaaS)으로 분류 가능하며, 자사 서비스의 위치를 파악하는 것이 전략 수립의 출발점이다.
• 4-Layer 아키텍처: Gen.AI 서비스는 Application, Platform, Model, Infrastructure 4개 레이어로 구성되며, 기존 서비스 대비 복잡성이 높아 레이어별 역할 정의가 중요하다.
• 전문성 기반 분업: Product(개발·운영), Data(파이프라인), RAG(기술 연구·적용) 팀이 각자의 전문 영역에 집중하는 것이 스타트업 환경에서도 효율적이다.
• 문제 진단 역량: 표면적 기술 적용보다 개념 이해가 선행되어야 실전에서 신속정확한 문제 진단과 대응이 가능하다.

상세 내용​

AI Service 이해의 중요성​

AI 기술의 발전 속도는 가속화되고 있다. RAG(Retrieval Augmented Generation)는 이미 많은 실무자에게 익숙한 개념이 되었지만, 투입 리소스 대비 성능 향상에 대한 고도화는 여전히 진행 중이다. 그럼에도 불구하고 업계는 AI Agent를 향해 빠르게 움직이고 있다.

이러한 빠른 전환 과정에서 실무자들이 간과하기 쉬운 점이 있다. LLM, RAG, Agent의 본질적 개념과 특징에 대한 깊이 있는 이해 없이 서비스 구축에만 집중하는 경우가 많다는 것이다. 이는 문제 상황에서 신속정확한 대처를 어렵게 만들고, 심각한 경우 명확한 문제 진단조차 불가능하게 만든다.

본 문서는 실무자가 마주하는 AI Service의 개괄적 특징과 명확히 알아야 할 본질적 개념을 정리하여, 실전에서 활용 가능한 참고 자료를 제공하고자 한다.

Gen.AI Service의 분류 체계​

기술 관점에서의 분류​

현존하는 생성형 AI 서비스는 기술적 특성에 따라 6가지 유형으로 구분할 수 있다:

자사 서비스가 어느 유형에 속하는지, 혹은 여러 유형의 특성을 조합하고 있는지 파악하는 것이 서비스 전략 수립의 첫 단계다.

비즈니스 모델 관점에서의 분류​

Gen.AI 서비스는 타겟 고객과 제공 형태에 따라 다음과 같이 분류할 수 있다:

이 분류를 통해 자사 서비스의 수익 모델과 경쟁 구도를 명확히 이해할 수 있다.

아키텍처 관점: 4-Layer 구조​

Gen.AI 서비스는 BM과 특성이 다양하더라도, 기본적으로 4개의 레이어로 구성된 아키텍처를 따른다:

1. Application Layer

• 실제 고객과 직접 접점을 형성하는 레이어
• 서비스의 접근 형태(B2B, B2C), UI/UX, 사용자 경험을 담당
• 고객의 요구사항이 시스템으로 전달되는 진입점

2. Platform Layer

• 비즈니스 로직과 AI 기능을 연결하는 중간 레이어
• API 게이트웨이, 오케스트레이션, 워크플로우 관리 등을 담당
• RAG, Agent와 같은 AI 기능이 실제로 구현되는 영역

3. Model Layer

• LLM, Embedding 모델 등 AI 모델이 위치하는 레이어
• 모델 선택, 파인튜닝, 프롬프트 엔지니어링이 이루어지는 영역
• 서비스의 AI 성능을 직접 결정하는 핵심 레이어

4. Infrastructure Layer

• GPU, 스토리지, 네트워크 등 물리적·클라우드 인프라
• 모델 서빙, 스케일링, 모니터링을 지원
• 비용과 성능의 트레이드오프가 결정되는 레이어

Gen.AI 서비스는 이 4개 레이어가 유기적으로 연결되어야 하며, 기존 서비스 대비 복잡성이 높다. 각 레이어의 역할을 명확히 이해하고 레이어 간 인터페이스를 잘 설계하는 것이 중요하다.

실무자의 역할 분담​

회사가 올바른 방향성을 가지고 시너지를 극대화하려면, 각 팀의 실무자가 전문성을 기반으로 명확한 역할을 수행해야 한다. 다음은 효과적인 역할 분담의 예시다:

Product Team

• 서비스 기능의 직접 개발
• 배포된 서비스의 전반적인 유지보수, 운영, 대응
• 고객 피드백 수렴 및 기능 개선

Data Team

• 서비스 기능에 필요한 데이터 수급 및 전처리
• 데이터 레이크, 파이프라인 등 전반적인 데이터 인프라 운용/관리
• 데이터 품질 관리 및 거버넌스

RAG Team

• RAG/Agent에 대한 지엽적인 기술 연구
• 연구 결과를 바탕으로 한 서비스 적용 및 반영
• 프롬프트 엔지니어링, 모델 최적화 등 AI 성능 개선

물론 스타트업 환경에서는 인력 규모의 제약으로 인해 역할의 경계가 모호할 수 있다. 하지만 LLM, RAG, Agent는 기존 방식과 다른 특성을 가지고 있기 때문에, 모든 팀원이 표면적인 부분만 다루기보다는 각 팀이 강점을 가진 영역에 집중하여 전문성을 높이는 것이 장기적으로 효과적이다.

서비스 정의의 중요성​

모든 논의의 출발점은 "만들고 운용하고자 하는 서비스의 명확한 정의"다. 서비스의 기술적 분류, BM, 아키텍처, 타겟 고객을 명확히 정의하지 않으면 팀 간 협업이 비효율적이고 방향성이 흐려진다.

서비스 정의가 명확해지면:

• 각 팀이 집중해야 할 우선순위가 분명해진다
• 레이어별 책임 영역이 구분되어 병목 지점 파악이 쉬워진다
• 기술 선택과 투자 결정이 데이터 기반으로 이루어진다
• 문제 발생 시 근본 원인 분석과 빠른 대응이 가능하다

References​

• 원본 문서: 여러분은 AI Service에 대해 얼마나 알고 계신가요?

프롬프트 캐싱은 AI 에이전트의 비용을 최대 90% 절감하고 응답 속도를 획기적으로 개선하는 핵심 기술입니다. 접두사 매칭(Prefix Matching) 원리에 기반하여, 변하지 않는 컨텍스트는 앞에 배치하고 동적 요소는 뒤로 보내는 전략이 필수적입니다. 시스템 프롬프트에 타임스탬프를 넣거나 도구 세트를 수시로 변경하는 등 캐시를 무효화하는 안티패턴을 피하고, 캐시 히트율을 시스템 가용성만큼 중요한 지표로 모니터링해야 합니다. Claude Code 팀의 실전 경험에서 나온 5가지 골든 룰을 따르면 비용 효율성과 사용자 경험을 동시에 극대화할 수 있습니다.

Key Takeaways​

• 프롬프트 레이아웃 설계가 핵심: 전역 정적 콘텐츠 → 프로젝트 컨텍스트 → 세션 컨텍스트 → 대화 기록 순으로 계층화하여 여러 세션이 상단부 캐시를 공유하도록 설계
• 캐시 무효화 방지 원칙: 시스템 프롬프트에 동적 정보(타임스탬프 등) 절대 삽입 금지, 모델과 도구 세트는 고정하고 서브 에이전트로 유연성 확보
• 도구 기반 상태 관리: 프롬프트를 직접 수정하는 대신 EnterPlanMode 같은 도구 호출로 상태 전환을 구현하여 정적 프롬프트 구조 보호
• 지연 로딩 패턴 활용: 수십 개의 도구는 스텁(Stub)으로 제공하고 ToolSearch로 필요할 때만 상세 스키마 로드하여 접두사 안정성 유지
• 캐시 히트율을 SLA로 관리: 히트율을 시스템 가용성 수준의 KPI로 취급하고, 일정 수준 이하로 떨어지면 알람을 발생시키는 운영 체계 구축

상세 내용​

왜 프롬프트 캐싱이 AI 에이전트의 생존 전략인가​

현대적인 AI 에이전트는 Claude Code처럼 긴 대화 세션을 유지하고, 대규모 코드베이스를 참조하며, 반복적인 도구 호출(Tool Call)을 수행합니다. 이 과정에서 매 요청마다 수만 개의 토큰을 모델에 새로 입력하는 것은 두 가지 치명적인 문제를 야기합니다.

첫째, 비용 폭증입니다. 일반적인 입력 토큰 비용은 프로덕션 환경에서 빠르게 누적되며, 특히 장시간 세션이나 대규모 컨텍스트를 다루는 에이전트의 경우 운영 비용이 비즈니스 모델 자체를 위협할 수 있습니다.

둘째, 레이턴시 증가입니다. 모델이 입력을 처음부터 다시 처리(Prefilling)하는 시간은 사용자 경험에 직접적인 영향을 미칩니다. 특히 실시간 코딩 어시스턴트처럼 빠른 피드백이 중요한 애플리케이션에서는 몇 초의 지연도 사용 가능성을 크게 저하시킵니다.

프롬프트 캐싱(Prompt Caching)은 이전 요청에서 계산된 컨텍스트를 재사용하여 이 두 문제를 동시에 해결합니다:

• 최대 90%의 비용 절감: 캐시된 토큰은 신규 입력 토큰 대비 대폭 할인된 가격으로 처리됩니다
• 응답 속도 향상: Prefilling 단계를 건너뛰어 응답 시작 시간(Time to First Token)이 비약적으로 단축됩니다

접두사 매칭(Prefix Matching): 캐싱의 작동 원리​

프롬프트 캐싱은 '접두사 매칭'이라는 엄격한 규칙에 따라 작동합니다. API는 요청의 시작 부분부터 특정 캐시 브레이크포인트(Breakpoint)까지의 내용이 이전 요청과 완전히 동일할 때만 캐시를 적용합니다.

여기서 "완전히 동일"이란 표현이 핵심입니다:

• 단 하나의 문자가 다르거나
• 공백 하나가 추가되거나
• 도구 정의의 순서가 바뀌거나
• JSON 키의 직렬화 순서가 달라지면

해당 지점 이후의 모든 캐시는 즉시 무효화(Invalidate)됩니다.

이러한 특성 때문에 캐싱 전략의 핵심 원칙이 도출됩니다:

"변하지 않는 것은 앞으로, 자주 변하는 것은 뒤로"

이 원칙을 지키지 않으면 캐시가 지속적으로 깨지면서 오히려 캐시 생성 비용만 발생하여 역효과가 납니다.

프롬프트 레이아웃의 4계층 구조​

Claude Code 팀이 실전에서 검증한 최적의 프롬프트 구조는 변경 빈도에 따라 다음과 같이 4계층으로 구성됩니다:

1. 전역 정적 컨텐츠 (Static System Prompt & Tools)

• 모든 사용자, 모든 세션에서 공통으로 사용되는 시스템 지침
• 기본 도구(Tool) 정의 세트
• 가장 변경이 적고, 가장 많은 세션이 공유하는 레이어

2. 프로젝트 컨텍스트 (Project-specific Context)

• 특정 프로젝트의 코딩 규칙이나 아키텍처 가이드
• CLAUDE.md 같은 프로젝트 설정 파일
• 프로젝트 내 모든 세션이 공유

3. 세션 컨텍스트 (Session Context)

• 현재 사용자 세션의 고유 정보
• 작업 중인 파일 목록이나 초기 상태
• 한 세션 내에서는 안정적으로 유지

4. 대화 기록 (Conversation Messages)

• 실시간으로 추가되는 사용자-모델 간 메시지
• 가장 빈번하게 변경되는 레이어

이 순서를 엄격히 지켜야 여러 사용자와 세션이 상위 레이어의 캐시를 효과적으로 공유하여 전체 시스템의 캐시 히트율(Hit Rate)을 극대화할 수 있습니다.

캐시 무효화를 방지하는 5가지 골든 룰​

1. 시스템 프롬프트에 동적 정보 삽입 금지​

가장 흔한 실수는 시스템 프롬프트에 타임스탬프를 포함하는 것입니다:

❌ 나쁜 예:
You are a helpful assistant. Current time: 2024-02-20 14:32:15

이렇게 하면 매분마다 캐시가 무효화되어 캐싱의 효과가 완전히 사라집니다.

✅ 좋은 예:
시스템 프롬프트: You are a helpful assistant.
최신 사용자 메시지: [현재 시각: 2024-02-20 14:32:15] 사용자 질문...

날짜, 시간, 세션 ID 같은 동적 정보는 반드시 대화의 최신 메시지나 별도의 시스템 메시지로 전달하여 상단부의 정적 접두사를 보호해야 합니다.

2. 모델 및 도구 세트 고정​

모델 전환의 함정 비용을 절감하려고 대화 중간에 claude-opus-4 → claude-haiku-3.5로 모델을 바꾸면 캐시를 처음부터 다시 쌓아야 하므로 오히려 더 많은 비용이 발생할 수 있습니다.

해결책: 주요 에이전트는 고성능 모델로 고정하고, 비용 최적화가 필요한 서브 태스크는 별도의 서브 에이전트(Sub-agent)로 분리하여 각각 최적의 모델을 사용하게 합니다.

도구 세트의 안정성 특정 상황에만 도구를 노출하려고 도구 정의를 동적으로 추가/제거하면 캐시가 지속적으로 깨집니다.

해결책: 모든 가능한 도구를 항상 정의해두고, 시스템 지침이나 컨텍스트를 통해 "지금은 이 도구만 사용하라"고 모델을 가이드합니다. 모델은 충분히 똑똑해서 이런 지침을 잘 따릅니다.

3. 상태 전환을 도구로 구현하기 (Plan Mode 사례)​

사용자가 "계획 모드"에 진입할 때 시스템 프롬프트를 수정하는 대신, 다음과 같이 도구를 활용합니다:

# ❌ 나쁜 예: 프롬프트 직접 수정
system_prompt = base_prompt + "\n\nYou are now in plan mode..."

# ✅ 좋은 예: 도구 호출로 상태 전환
tools = [
    {
        "name": "EnterPlanMode",
        "description": "Switch to planning mode for high-level design"
    }
]

# 모델이 EnterPlanMode를 호출하면
# tool_result로 상태 메시지 반환
tool_result = {
    "type": "system",
    "content": "Now in plan mode. Focus on architecture..."
}

모델은 도구 호출 결과로 전달된 시스템 메시지를 통해 현재 상태를 인식하고, 정적 프롬프트는 전혀 변경되지 않아 캐시가 유지됩니다.

4. 도구 검색(Tool Search)과 지연 로딩(Deferred Loading)​

수십 개의 도구를 모두 정의하면 초기 컨텍스트가 너무 커져 비용이 증가합니다. 하지만 도구를 제거하면 캐시가 깨지는 딜레마가 발생합니다.

해결책: 스텁(Stub) + 지연 로딩 패턴

# 초기에는 이름과 간단한 설명만 제공
tools = [
    {"name": "ToolA", "description": "Brief description"},
    {"name": "ToolB", "description": "Brief description"},
    # ... 수십 개
    {"name": "ToolSearch", "description": "Get detailed schema for a tool"}
]

# 모델이 ToolSearch("ToolA")를 호출하면
# 그때 상세 스키마를 반환
detailed_schema = {
    "name": "ToolA",
    "parameters": {...},  # 상세 파라미터 정보
    "examples": [...]
}

이 패턴을 사용하면 도구 목록 자체는 안정적으로 유지되어 접두사 캐시가 보존되면서도, 필요한 순간에만 상세 정보를 로드하여 초기 컨텍스트 크기를 최소화할 수 있습니다.

5. 캐시 세이프 포킹(Cache-safe Forking)​

대화가 길어져 컨텍스트 윈도우가 가득 차면 요약(Compaction)이 필요합니다. 이때 새로운 빈 세션을 만들어 요약하면 기존 캐시를 전혀 활용하지 못합니다.

최적화된 요약 전략:

# ❌ 비효율적: 새 세션으로 요약
new_request = {
    "system": system_prompt,
    "messages": [{"role": "user", "content": "Summarize this: " + full_history}]
}

# ✅ 효율적: 기존 컨텍스트 유지 + 요약 요청 추가
fork_request = {
    "system": system_prompt,  # 캐시됨
    "tools": tools,             # 캐시됨
    "messages": [
        ...existing_messages,    # 캐시됨
        {"role": "user", "content": "Summarize the conversation so far"}
    ]
}

기존 대화의 모든 컨텍스트를 그대로 포함한 채 마지막에 요약 요청만 추가하면, 이전 계산량을 100% 재사용하면서 요약본만 새로 생성할 수 있습니다. 이를 "캐시 세이프 포킹"이라고 부르며, Claude Code 팀이 실전에서 검증한 강력한 패턴입니다.

운영 및 모니터링: 캐시 히트율을 SLA처럼 관리하기​

Claude Code 팀은 프롬프트 캐시 히트율을 시스템 가용성(Uptime)과 동등한 수준의 핵심 지표로 관리한다고 밝혔습니다.

모니터링 전략:

• 캐시 히트율 대시보드: 실시간으로 히트율을 추적하고 시각화
• 알람 설정: 히트율이 기준치(예: 85%) 이하로 떨어지면 즉시 경고 발생
• 장애 대응: 히트율 급락을 서비스 장애와 동일하게 취급하여 긴급 조사

비결정성(Non-determinism) 제거: 캐시가 예상치 못하게 깨지는 가장 흔한 원인은 직렬화(Serialization) 과정의 비결정성입니다.

# ❌ 문제 있는 코드: Dictionary 순서가 랜덤
tools = {
    "tool_a": {...},
    "tool_b": {...}
}
json_str = json.dumps(tools)  # 순서가 매번 달라질 수 있음

# ✅ 안전한 코드: 순서 명시적 보장
tools = OrderedDict([
    ("tool_a", {...}),
    ("tool_b", {...})
])
json_str = json.dumps(tools, sort_keys=True)

Python의 일반 dict, Java의 HashMap 등은 삽입 순서를 보장하지 않거나 버전에 따라 동작이 다를 수 있습니다. 캐시 안정성을 위해서는 항상 순서를 명시적으로 제어해야 합니다.

Claude Code의 실전 활용​

Claude Code는 터미널, IDE(VS Code, JetBrains), 데스크톱 앱, 웹 브라우저 등 다양한 환경에서 동작하는 AI 코딩 어시스턴트입니다. 전체 코드베이스를 이해하고, 여러 파일을 동시에 편집하며, 개발 도구와 통합되어 작동합니다.

이러한 복잡한 멀티턴 상호작용에서 프롬프트 캐싱은 선택이 아닌 필수입니다. Claude Code 팀이 공유한 전략들은 실제 프로덕션 환경에서 수십만 세션을 처리하며 검증된 베스트 프랙티스입니다.

설치 및 시작:

# macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash

# 프로젝트에서 실행
cd your-project
claude

Claude Code는 Native Install 방식으로 설치하면 자동 업데이트가 활성화되어 최신 기능과 보안 패치를 자동으로 받을 수 있습니다.

결론: 설계 단계부터 캐시를 고려하라​

프롬프트 캐싱은 단순히 비용을 줄이는 최적화 기법이 아닙니다. 이것은 다음을 결정짓는 핵심 설계 원칙입니다:

• 사용자 경험: 응답 속도가 빠른 에이전트는 사용자 만족도와 리텐션을 크게 향상시킵니다
• 비즈니스 모델: 90%의 비용 절감은 수익성과 확장성을 직접적으로 개선합니다
• 시스템 안정성: 캐시 히트율을 SLA로 관리하면 예측 가능한 운영이 가능합니다

AI 에이전트를 개발할 때 프로토타입 단계부터 프롬프트 레이아웃을 캐시 친화적으로 설계하는 것이 현대적인 AI 엔지니어링의 표준입니다. 나중에 리팩토링하려면 훨씬 큰 비용이 들기 때문입니다.

Claude Code 팀의 5가지 골든 룰을 따르고, 캐시 히트율을 핵심 지표로 모니터링하면, 비용 효율적이면서도 뛰어난 사용자 경험을 제공하는 AI 에이전트를 구축할 수 있습니다.

References​

• AI 에이전트 최적화의 핵심: 프롬프트 캐싱(Prompt Caching) - LinkedIn Post
• Claude Code Documentation - Getting Started

OpenAI의 공동 창립자 Ilya Sutskever가 John Carmack에게 제시한 약 30편의 딥러닝 필독 논문 목록입니다. "이것들을 제대로 학습하면 오늘날 중요한 것의 90%를 알게 될 것"이라는 말과 함께 공유된 이 리스트는 Transformer 아키텍처, RNN/LSTM, ResNet 같은 핵심 모델부터 복잡도 이론과 Kolmogorov Complexity 같은 이론적 기초까지 망라합니다. 현대 딥러닝의 필수 개념들을 체계적으로 학습할 수 있는 커리큘럼으로, AI Research Engineer라면 반드시 숙지해야 할 핵심 지식의 정수입니다.

Key Takeaways​

• 선별된 핵심 논문들: 방대한 딥러닝 연구 중에서 실제로 중요한 90%를 커버하는 약 30편으로 압축된 ��리큘럼
• 이론과 실무의 균형: Attention 메커니즘, ResNet 같은 실용적 아키텍처부터 Kolmogorov Complexity, MDL 같은 이론적 기초까지 포괄
• 시대를 초월한 기초: RNN/LSTM 같은 초기 시퀀스 모델부터 Transformer, Scaling Laws까지 진화 과정을 이해할 수 있는 구성
• 실용적 구현 자료: 대부분의 논문에 코드 구현이나 주석이 달린 튜토리얼이 포함되어 있어 학습과 동시에 실습 가능
• 압축과 복잡도 관점: MDL, Kolmogorov Complexity 등을 통해 신경망을 정보 이론적 관점에서 이해하는 깊이 있는 시각 제공

상세 내용​

리딩 리스트의 배경과 의의​

OpenAI의 Chief Scientist이자 공동 창립자인 Ilya Sutskever는 게임 개발의 전설 John Carmack에게 "만약 이것들을 제대로 학습한다면, 오늘날 중요한 것의 90%를 알게 될 것"이라는 말과 함께 이 리스트를 공유했습니다. 이는 단순한 논문 목록이 아니라, 현대 딥러닝의 핵심을 관통하는 체계적인 학습 경로입니다.

이 목록의 특징은 최신 논문만을 추구하지 않고, 시대를 초월한 기본 원리와 실용적인 최신 기술을 균형있게 배치했다는 점입니다. 이론적 기초(Kolmogorov Complexity, MDL)부터 실용적 아키텍처(Transformer, ResNet), 그리고 스케일링 법칙까지 딥러닝의 과거, 현재, 미래를 아우릅니다.

핵심 아키텍처 논문들​

Transformer와 Attention 메커니즘

• Attention Is All You Need (Vaswani et al.): 현대 LLM의 근간이 되는 Transformer 아키텍처의 원조 논문
• The Annotated Transformer: Harvard NLP 팀이 제공하는 line-by-line 구현과 주석. 단순히 논문을 읽는 것을 넘어 실제로 작동하는 코드와 함께 학습 가능
• Neural Machine Translation by Jointly Learning to Align and Translate (Bahdanau et al.): Attention 메커니즘의 초기 제안으로, Transformer 이전에 어떻게 시퀀스 모델에서 선택적 집중이 가능했는지 이해하는 데 필수

RNN과 LSTM의 이해

• The Unreasonable Effectiveness of Recurrent Neural Networks (Andrej Karpathy): RNN의 놀라운 생성 능력을 직관적으로 보여주는 블로그 포스트. 문자 단위 언어 모델이 어떻게 의미 있는 텍스트를 생성하는지 설명
• Understanding LSTM Networks (Christopher Olah): LSTM의 내부 구조를 시각적으로 명쾌하게 설명한 고전적 튜토리얼
• Recurrent Neural Network Regularization (Zaremba et al.): RNN 학습의 실용적 측면을 다루며, dropout 같은 정규화 기법의 적용

Convolutional Networks와 Computer Vision

• ImageNet Classification with Deep Convolutional Neural Networks (AlexNet): 딥러닝 부흥의 시발점이 된 역사적 논문
• Deep Residual Learning for Image Recognition (ResNet): Skip connection을 통해 매우 깊은 네트워크 학습을 가능하게 한 혁신
• Identity Mappings in Deep Residual Networks: ResNet의 개선 버전으로, 왜 특정 구조가 더 잘 작동하는지에 대한 이론적 이해 제공

이론적 기초와 철학​

복잡도와 정보 이론

• The First Law of Complexodynamics (Scott Aaronson): Kolmogorov complexity를 활용하여 물리 시스템의 복잡도가 시간에 따라 어떻게 변하는지 설명. 엔트로피는 단조 증가하지만 "재미있음(interestingness)"은 증가했다 감소한다는 통찰 제공

• Keeping Neural Networks Simple by Minimizing the Description Length of the Weights (Hinton): MDL(Minimum Description Length) 원리를 신경망에 적용. 모델의 복잡도를 가중치를 설명하는 데 필요한 비트 수로 측정

• A Tutorial Introduction to the Minimum Description Length Principle: 압축과 학습의 관계에 대한 근본적 이해. 좋은 모델은 데이터를 잘 압축하는 모델

• Kolmogorov Complexity and Algorithmic Randomness: 객체의 본질적 복잡도를 정의하는 수학적 프레임워크. 일반화와 압축의 관계를 이해하는 이론적 토대

철학적 고려사항

• Machine Super Intelligence (Shane Legg): DeepMind 공동 창립자의 박사 논문. AGI에 대한 수학적이고 철학적인 접근

실용적 기법과 시스템​

스케일링과 병렬화

• Scaling Laws for Neural Language Models (Kaplan et al.): 모델 크기, 데이터, 컴퓨팅의 관계를 정량화한 획기적 연구. 현대 LLM 개발의 나침반 역할

• GPipe: Easy Scaling with Micro-Batch Pipeline Parallelism: 거대 모델을 효율적으로 학습시키기 위한 파이프라인 병렬화 기법

특수 아키텍처와 응용

• Pointer Networks: 출력이 가변 길이 이산 토큰인 문제(조합 최적화 등)를 다루는 혁신적 접근

• Neural Turing Machines: 외부 메모리를 가진 신경망으로, 알고리즘 학습 가능성 탐구

• Deep Speech 2: End-to-end 음성 인식의 실용적 구현

• Order Matters: Sequence to sequence for sets: 순서가 없는 집합을 다루면서도 순서가 중요한 시퀀스 모델의 특성 활용

관계 추론과 구조​

• A simple neural network module for relational reasoning: 객체 간 관계를 추론하는 네트워크 모듈

• Relational recurrent neural networks: RNN에 관계 추론 능력을 부여

• Neural Message Passing for Quantum Chemistry: 그래프 신경망을 화학 분자 특성 예측에 적용

생성 모델과 표현 학습​

• Variational Lossy Autoencoder: VAE의 개선된 형태로, 더 나은 생성과 압축의 균형

교육 자료​

• CS231n: Convolutional Neural Networks for Visual Recognition: Stanford의 유명한 딥러닝 강의. 체계적인 기초 학습을 위한 커리큘럼

학습 순서와 전략​

이 리스트를 효과적으로 학습하기 위한 제안:

1. 기초부터 시작: CS231n으로 기본 개념 확립
2. RNN 계열 이해: Karpathy와 Olah의 블로그로 직관 형성 → LSTM 정규화로 실용 지식 습득
3. Attention과 Transformer: Bahdanau attention → Transformer 논문 → Annotated Transformer로 구현까지
4. 컴퓨터 비전 기초: AlexNet → ResNet으로 발전 과정 이해
5. 이론적 심화: MDL, Kolmogorov Complexity로 깊이 있는 이해
6. 스케일링과 실용화: Scaling Laws, GPipe 등으로 현대적 관점 확보

대부분의 자료가 코드나 상세한 튜토리얼과 함께 제공되므로, 단순히 읽는 것을 넘어 직접 구현하고 실험하는 것이 핵심입니다. The Annotated Transformer처럼 working notebook 형태의 자료들은 학습과 실습을 동시에 가능하게 합니다.

References​

• Original Reading List - Ilya 30u30 Folder
• The Annotated Transformer
• The Annotated Transformer - GitHub
• The First Law of Complexodynamics - Scott Aaronson
• The Unreasonable Effectiveness of Recurrent Neural Networks - Andrej Karpathy
• Understanding LSTM Networks - Christopher Olah
• char-rnn GitHub Repository
• Recurrent Neural Network Regularization (ArXiv)
• LSTM Regularization Code
• Attention Is All You Need
• Scaling Laws for Neural Language Models

디퓨전(diffusion) 기반 LLM은 기존 오토리그레시브 방식과 달리 여러 토큰을 병렬로 생성·정제하여 5~10배 빠른 추론 속도를 제공합니다. 이미지 생성에 혁신을 가져온 디퓨전 기술이 텍스트 생성으로 확장되고 있으며, 내장된 오류 수정 메커니즘과 메모리 대역폭 효율성이 핵심 장점입니다. 한편 엔터프라이즈 AI 도입에서는 기술보다 ROI가 우선이며, 레거시 시스템 통합과 실질적 비즈니스 가치 측정이 성공의 핵심입니다.

Key Takeaways​

• 디퓨전 LLM의 병렬 처리: 순차적 토큰 생성 대신 여러 토큰을 동시에 생성·정제하여 유사 품질 대비 5~10배 속도 향상 달성
• 메모리 효율성이 속도의 핵심: 가중치를 한 번 로드하여 여러 토큰에 적용하므로 메모리 대역폭 병목 현상을 크게 완화
• 내장된 오류 수정 메커니즘: 반복 정제 과정에서 자체적으로 실수를 교정할 수 있는 구조적 장점 (단, 환각 문제는 여전히 존재)
• 엔터프라이즈 AI는 ROI First: AI 투자 1달러당 실제 가치를 추적하는 것이 기술 선택보다 우선이며, TCO 기반 ROI 계산이 필수
• 레거시 시스템이 실제 시장: COBOL과 메인프레임 같은 레거시 코드 유지보수가 바이브코딩 도구보다 실질적 수요가 크며, 특화 LLM이 필요

상세 내용​

디퓨전 LLM의 작동 원리와 차별점​

기존 LLM(ChatGPT, Gemini 등)은 토큰을 왼쪽에서 오른쪽으로 하나씩 순차 생성하는 오토리그레시브(autoregressive) 방식을 사용합니다. 이는 본질적으로 순차적 연산이라 구조적 병목이 발생할 수밖에 없습니다.

반면 Inception이 개발 중인 디퓨전 LLM은 완전히 다른 접근법을 취합니다. 랜덤 토큰으로 시작해 여러 토큰을 병렬로 동시에 수정하면서 점진적으로 정제(denoising)합니다. 이는 이미지 디퓨전 모델이 노이즈 이미지에서 선명한 결과물을 만들어가는 것과 동일한 원리입니다.

학습 방식의 근본적 차이​

학습 방법론도 근본적으로 다릅니다:

• 기존 LLM: "다음 토큰 예측(next token prediction)" 목표로 학습
• 디퓨전 LLM: 깨끗한 텍스트에 의도적으로 오류를 주입한 뒤 "실수를 교정(error correction)" 하도록 학습

추론 시에도 이 철학이 이어져, 한 번에 최대한 많은 실수를 고치면서 깨끗한 출력을 만들어갑니다.

5~10배 속도 향상의 비밀: 메모리 대역폭​

디퓨전 LLM이 유사한 품질의 오토리그레시브 모델 대비 5~10배 빠른 이유는 메모리 대역폭 효율 덕분입니다.

기존 LLM은 각 토큰을 생성할 때마다 가중치를 메모리에서 로드해야 합니다. 이 과정에서 메모리 대역폭이 병목이 됩니다. 반면 디퓨전 모델은 가중치를 한 번 로드하면 여러 토큰에 동시에 적용할 수 있어 메모리 이동 횟수를 획기적으로 줄입니다.

내장된 오류 수정 메커니즘​

오토리그레시브 모델의 근본적 한계는 한 번 출력한 토큰을 되돌릴 수 없다는 점입니다. 한 번 잘못된 방향으로 가면 계속 잘못된 경로를 따라갈 수밖에 없습니다.

디퓨전 모델은 반복 정제 과정에서 실수를 수정할 수 있는 메커니즘이 구조적으로 내장되어 있습니다. 다만 Stefano Ermon CEO는 솔직하게 환각(hallucination) 문제가 완전히 해결된 것은 아니라고 인정했습니다.

현재 직면한 기술적 도전들​

디퓨전 LLM이 극복해야 할 과제들:

1. 반복 루프 문제 비슷한 내용을 계속 반복 생성하는 현상이 발생합니다. 이는 이미지 디퓨전의 "손가락 6개 문제"에 해당하며, Google의 Gemini Diffusion에서도 동일한 문제가 관찰되었습니다.

2. 가변 길이 처리 이미지는 고정 크기(예: 512×512)이지만 텍스트는 길이가 가변적입니다. 이를 처리하는 것이 핵심 기술적 도전입니다.

3. 이산(discrete) 데이터 처리 디퓨전 수학은 본질적으로 연속적입니다(편미분방정식, Fokker-Planck 방정식 기반). 반면 토큰은 유한하고 이산적이라, 이를 변환하는 새로운 수학적 프레임워크가 필요했습니다.

4. 설계 선택의 재검토 토크나이저를 비롯한 많은 설계 요소들이 오토리그레시브 모델에 최적화되어 있습니다. 디퓨전 모델에는 비최적적이며, 아직 개선 여지가 많습니다.

미래 방향: 추론, 새로운 아키텍처, 월드 모델​

Inception은 현재 추론(reasoning) 능력을 개발 중이며, 기존 o1이나 DeepSeek 방식과는 완전히 다른 접근이라고 합니다.

또한 트랜스포머 외에 상태 기반 모델(State Space Model) 같은 대안 아키텍처와도 결합 가능합니다. 월드 모델(world model) 분야에서는 디퓨전이 이미 핵심 기술로 자리잡고 있다고 언급했습니다.

ROI First: 엔터프라이즈 AI의 실질적 접근법​

업계에 "AI First", "Data First" 같은 버즈워드가 넘쳐나지만, Roomie의 Aldo Luévano 회장은 경영진이 실제로 원하는 것은 **"ROI First"**라고 강조합니다.

Roomie의 핵심 철학은 명확합니다: AI에 투자한 1달러당 얼마의 가치가 돌아오는지 추적하는 것입니다. 이를 위해 플랫폼에 ROI 추적 모듈을 내장했습니다.

프로세스는 다음과 같습니다:

1. 컨설턴트가 GPT 기반 대화를 통해 비즈니스 요구사항 파악
2. 수동/반자동 프로세스의 현재 TCO(Total Cost of Ownership) 계산
3. AI 도입 후의 TCO 예측
4. ROI 산출 및 추적

레거시 시스템: 간과된 거대 시장​

Cursor, Replit, Lovable 같은 바이브코딩 도구는 새로운 소프트웨어를 만드는 데 초점이 맞춰져 있습니다. 하지만 Luévano는 실제 시장의 대부분은 메인프레임과 COBOL 같은 레거시 시스템이라고 지적합니다.

Roomie는 11년간 금융, 은행, 소비재, 유통, 공공부문 등 다양한 프로젝트 경험에서 축적한 데이터로 모델을 학습시켰습니다. 특히 자연어로 레거시 코드의 유지보수와 신규 기능 개발을 지원하는 특화 LLM/SLM을 보유하고 있습니다.

COBOL 개발자들이 고령화되고 있어 이 문제가 더욱 절실해지고 있으며, 이는 많은 기업들이 직면한 실질적 과제입니다.

피지컬 AI와 로보틱스 통합​

Roomie는 원래 B2B 로보틱스 스타트업으로 시작했으며, 현재도 물리적 AI 모듈을 운영합니다.

에이전틱 AI와 물리적 디바이스(휴머노이드 로봇, 엣지 디바이스)를 통합하며, **컴퓨터 비전(CNN 기반)**으로 다음을 수행합니다:

• 공장 피킹(picking)
• 셀프 체크아웃
• 이상 패턴 감지

차별점은 단순 알림이 아니라, 패턴 인식 후 에이전트가 실제 액션을 취한다는 점입니다.

AI와 일자리: 솔직한 대화​

많은 회사들이 "AI가 일자리를 줄이지 않는다"고 말하지만, Luévano는 AI 도입이 인력 감축으로 이어질 수 있음을 솔직하게 인정했습니다.

다만 동시에 새로운 직종도 생겨날 것이라고 언급했습니다:

• 로봇 원격 조작
• 로봇 훈련 및 관리
• AI/로보틱스 UI 관리

이것이 사회 전체의 전환 과정이며, 투명한 대화가 필요하다는 입장입니다.

References​

• Generating text with diffusion (and ROI with LLMs) - Stack Overflow Blog
• Inception - Diffusion Language Models
• Roomie - Enterprise AI and Robotics Platform