트렌딩 딥다이브 · 2026-07-23 · TrendShift Daily #11 · KUNGFU

kungfu-systems/kungfu 딥다이브
— 채팅이 끝나도 에이전트가 처음부터 다시 시작하지 않게 하는 작업 연속성 런타임

Kungfu(功夫)의 한 줄 정의는 Continuity for Agent Work — "에이전트 작업의 연속성"이다. 슬로건은 Never Guess. Facts Unfold.(추측하지 마라 · 사실이 펼쳐진다). 핵심 아이디어는 이렇다: AI 에이전트는 채팅 창(컨텍스트)이 닫히면 지금까지 한 일을 전부 잊는다. Kungfu는 에이전트가 실제로 한 작업을 지워지지 않고 검증 가능한 "사실(Fact)"과 "에피소드(Episode)"로 기록해, 새 에이전트가 처음부터 설명 듣지 않고도 하던 일을 이어가게 한다.

뿌리가 특이하다. Kungfu의 저지연 저널 엔진 yijinjing(易筋经)은 원래 초단타(HFT) 퀀트 트레이딩 시스템으로 태어났다. 나노초 단위로 주문·체결을 절대 잃지 않게 기록하던 그 엔진을, v4에서 "에이전트가 한 일을 잃지 않게 기록하는" 범용 런타임으로 일반화한 것이 이 프로젝트다. 그래서 18,000개가 넘는 커밋과 실전에서 다져진 C++ 코어를 밑천으로 갖고 있다.

(저장소 kungfu-systems/kungfu · 브랜치 dev/v4/v4.0 · v4.0.0-alpha (shifu-v4.0.0-alpha.0, 2026-07-10) · 상태 Coming soon · 라이선스 Apache-2.0 · 언어 C++ 51% · JS 20% · Python 17% · TS 7% · Rust 5% · 핵심 yijinjing 저널 · libkungfu 런타임 · shifu 빌드 오케스트레이터 · Xinfa 컨텍스트 컴파일러 · KFD 에이전트 공급망 · ⭐ 약 4.3k · shallow clone 소스 직접 분석)
목차
  1. 프로젝트 한 줄 요약
  2. 왜 주목받는가 — HFT 저널을 에이전트 기억으로
  3. 기술 스택 전체 지도 — 4개 언어가 한 저널 위에
  4. 아키텍처 심화 — Fact·Episode·Cut·Trust
  5. 디렉토리 구조 해부
  6. 학습 포인트 — 여기서 훔쳐올 설계
  7. 시스템 / 빌드 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한 줄 요약

"에이전트에게 왜 매번 처음부터 다시 설명해야 하나" — 그 질문에 대한 저지연 저널식 대답
한 문장으로

Kungfu = 에이전트 작업의 블랙박스 + 항해일지. 대화가 사라져도 "무슨 일이 있었나(Episode)"와 "지금 무엇이 참인가(Fact)"가 봉인된 채 검증 가능하게 남는다.

지금의 코딩 에이전트(Claude Code · Codex 등)는 대부분 채팅 컨텍스트 = 유일한 기억이다. 창을 닫거나 컨텍스트가 꽉 차면, 무엇을 왜 했는지, 어떤 결정을 내렸는지, 어디까지 진행했는지가 통째로 증발한다. 다음 에이전트는 당신에게 다시 다 설명해 달라고 한다.

Kungfu는 그 사이에 지워지지 않는 작업 기록 계층을 놓는다. 프로젝트 소스에서 사실을 선언하고, 빠지거나 충돌하는 맥락을 눈에 보이게(추측으로 덮지 않고) 만들며, 대화 이력을 재구성하지 않고도 일을 이어갈 만큼의 구조를 남긴다.

이 프로젝트는 두 개의 얼굴을 가진다. 하나는 실전에서 검증된 저지연 저널 엔진(C++ yijinjing + libkungfu) — 원래 트레이딩용으로 "절대 데이터를 잃지 않는" 것이 목표였던 코어다. 다른 하나는 그 위에 얹힌 에이전트 연속성 제품kungfu run agent 한 줄로 에이전트를 돌리며 그 작업을 봉인된 에피소드로 남기는 것이 목표다. 아래가 이 프로젝트가 그리는 "골든 패스"다.

# 프로젝트 폴더에서, 목표로 삼은 첫 릴리스 진입점
cd your-project
kungfu run agent

# 설치된 런타임은 자신의 정책·프로토콜을 런타임 없이도 보여줄 수 있어야 한다
kungfu exit verify --info --json     # Exit(이탈) 정책 · 프로토콜 목록
kungfu agent brief                   # 에이전트용 로컬 브리핑
용어
Fact · Episode · Cut · 연속성(Continuity)
Fact(사실)는 특정 시점에 "참으로 인정된" 타입 있는 진술이다. Episode(에피소드)는 실제로 벌어진 작업의 인과 단위 — 그 사실들·산출물·의존성·영수증(receipt)·검증 뿌리를 묶은 것으로, 채팅 세션도 프로세스도 로그 뭉치도 아니다. Cut(컷)은 "이 질문에 답한 정확한 사실 경계"로, 과거의 답을 재현 가능하게 만든다. 연속성은 대화가 사라진 뒤에도 의도·현재 이해·행동 경계·결과가 남아 있는 상태를 뜻한다.

중요한 전제 두 가지. 첫째, Kungfu는 당신이 이미 쓰는 에이전트를 대체하지 않는다. kungfu run agent는 "골든 패스"일 뿐, Codex·Claude Code·VS Code·터미널은 그대로 쓰면서 같은 로컬 계약과 작업 상태를 공유하는 것이 목표다. 둘째, 현재 상태는 "Coming soon"(v4 알파)이다. 공개 CLI 아티팩트는 아직 없고, 소스 빌드로만 평가할 수 있다. 이 문서는 "무엇을 만들고 있는가"와 "왜 그 설계가 흥미로운가"에 초점을 두되, 프로젝트 자신이 강조하는 설계 의도 ≠ 구현됨 ≠ 검증됨 ≠ 릴리스됨의 구분을 그대로 존중한다.

2왜 주목받는가

"메모리 파일 하나 더"가 아니라, 트레이딩에서 온 저지연 저널 + 검증 계층

에이전트 메모리·연속성을 표방하는 도구는 이미 많다(메모리 MCP, CLAUDE.md류 지침 파일, 벡터 메모리…). Kungfu가 트렌딩에 오른 이유는 접근이 근본부터 다르기 때문이다 — "파일에 메모를 더 쌓자"가 아니라, 금융 트레이딩에서 검증된 저지연 append-only 저널과 콘텐츠 주소 지정·머클 루트·신뢰 경계를 통째로 가져왔다는 점이다.

핵심 주장 ①

뿌리가 HFT다 — "절대 잃지 않는 기록"이 태생적 요구였다

Kungfu의 데이터 평면인 yijinjing(易筋经 — 무협의 내공 수련서에서 딴 이름)은 나노초 단위 append-only mmap 저널이다. 원래 초단타 트레이딩에서 주문·체결·포지션을 한 건도 유실하지 않고, 재현 가능하게 남기려고 만들어졌다. 프로젝트 문서 스스로 "하나의 중립 코어 + 여러 도메인 프로파일"을 말하며, 그 도메인의 하나로 정량 트레이딩(주문/체결/포지션)을 Kungfu의 기원으로 명시한다.

바꿔 말하면, 에이전트 메모리를 "편의 기능"으로 새로 짠 것이 아니라, 돈이 걸린 실전에서 유실 불가·재현성이 필수였던 저널 엔진을 에이전트 작업이라는 새 도메인에 얹은 것이다. 18,000+ 커밋, C++ 51%라는 무게가 여기서 나온다.

둘째, "기록했다"와 "믿을 수 있다"를 분리한다. 대부분의 메모리 도구는 무언가를 적으면 그걸 곧 진실로 취급한다. Kungfu의 핵심 불변식은 정반대다:

recorded != admitted != trusted          # 기록됨 ≠ 인정됨 ≠ 신뢰됨
write returned != visible != durable != projected
# 쓰기가 반환됐다고 보이는 것도, 영구적인 것도, 투영된 것도 아니다

Claim + Purpose + Cut + Proof  ->  TrustReport
# 주장 + 목적 + 컷 + 증거  →  신뢰 보고서
# Facts are authoritative. Projections are rebuildable.

에이전트가 스스로 "다 했어요"라고 주장(Claim)해도, 그 주장은 자기 자신을 승인할 수 없다. 목적(Purpose)에 비춘 평가와 증거(Proof)를 거쳐야 신뢰 보고서(TrustReport)가 된다. 이 "자기 승인 불가" 원칙은, 에이전트가 환각으로 "성공했다"고 우기는 문제를 구조적으로 막으려는 시도다.

핵심 주장 ②

봉인된 에피소드 = Git처럼 콘텐츠 주소로 굳힌 작업 기록

완료된 작업은 sha256 머클 루트로 봉인(seal)돼 .kungfu/episodes/sealed/sha256/…에 콘텐츠 주소로 저장된다. 각 에피소드는 manifest.json(권위 있는 선언) + claims.jsonl(프레임 단위 기록) + qualification.json으로 이뤄진다. 즉 "무슨 일이 있었는가"가 Git 커밋처럼 해시로 굳어, 나중에 위·변조 없이 검증·재생(replay)·되감기(rewind)할 수 있다.

셋째, 자기 자신에게 먹여본다(dogfooding). 이 저장소 자체가 .kungfu/(봉인된 에피소드)와 .xinfa/(검증된 컨텍스트 Atlas)를 실제로 담고 있다. 개념을 슬라이드로만 파는 게 아니라, 저장소가 곧 살아있는 증거다. 그리고 KFD 에이전트 공급망이라는 더 큰 야심 — 서로 독립적으로 소유된 제품들 사이로 "책임 있는 작업 사실"을 표준 형식으로 실어 나른다는 구상 — 도 함께 제시한다.

눈여겨볼 것 — 드물게 정직한 상태 표기
"declared(선언됨)"와 "qualified(검증됨)"를 엄격히 구분

README·문서 곳곳이 "설계 의도 · 구현된 동작 · 검증된 보장 · 릴리스된 아티팩트는 일부러 별개로 둔다"고 못박는다. 내구성(durability)조차 "일회용 VM에서 360/360 강제 종료 시험은 통과했지만, 물리 하드웨어 정전 검증은 하지 않았다"고 스스로 한계를 명시한다. 과대광고가 흔한 에이전트 판에서, 이 절제된 자기검증 태도 자체가 신뢰 포인트다.

주의 — 아직 알파, 개념 밀도가 높다
쓸 수 있는 제품이 아니라 "평가할 수 있는 소스"

공개 릴리스 아티팩트가 없어 지금 당장 pip install/npm i로 써볼 수는 없다. 소스를 클론해 빌드해야 하고, 그마저 v4 알파다. 또 Fact/Episode/Cut/Watermark/Projection/TrustReport/KFD/Xinfa 등 자체 용어 밀도가 매우 높아 학습 곡선이 가파르다. "지금 도입할 도구"라기보다 "설계 사상을 공부할 레퍼런스"로 접근하는 게 맞다.

3기술 스택 전체 지도

C++ 코어가 심장, 나머지 3개 언어는 그 저널을 감싸는 껍질

Kungfu는 4개 언어가 하나의 저널 위에 층층이 쌓인 폴리글랏 모노레포다. 진짜 심장은 C++ 코어(framework/core, 전체의 93MB)이고, Rust·Node/TS·Python은 각자 다른 각도에서 그 코어를 감싼다. 언어마다 역할이 칼같이 나뉜다.

코어 (데이터 평면 + 런타임, C++23)

계층기술왜 이걸 썼나
데이터 평면libyijinjing (append-only mmap 저널)C++/Python/Node가 공유하는 단일 저지연 저널. journal/storage/io/platform/schema로 구성. 공개 API는 C++20으로 고정.
런타임libkungfu저널 위에서 Facts·Episodes·Cuts·Projections·TrustReport를 구현. 하위에 action/facts/live/query/trust/projection/state_cache/sandbox 등.
닫힌 스키마Boost.Hana 1.80 POD커널 레코드는 고정 레이아웃 POD(Hana 메타프로그래밍)로 저장 — 초저지연·제로카피.
열린 스키마FlatBuffers 25.9도메인 Fact는 FlatBuffers. JSON은 오직 "가장자리 투영(edge projection)"일 뿐, 저널 스키마가 아니다.
C++ 표준/빌드C++23 · CMake ≥3.28 · Ninja · Conan 2.29확장(extension) 금지, 생성기는 Ninja 고정. 프로덕션 컴파일러: macOS AppleClang · Linux GCC14 · Windows MSVC.
C++ 주요 의존fmt · spdlog · nng(nanomsg) · rxcpp · sqlite3 · rocksdb(선택) · xxhash · pybind11전송은 nng, 반응형은 rxcpp, 투영 저장은 sqlite3/rocksdb. 파이썬 바인딩은 pybind11.
용어
mmap 저널 · POD · FlatBuffers · edge projection
mmap 저널은 파일을 메모리에 직접 매핑해 append(뒤에 이어 붙이기)만 하는 로그다 — 디스크 쓰기가 메모리 쓰기처럼 빨라 HFT에 쓰인다. POD(Plain Old Data)는 고정 바이트 레이아웃 구조체로, 파싱 없이 그대로 읽어 제로카피가 된다. FlatBuffers는 역직렬화 없이 바로 접근하는 직렬화 포맷. edge projection은 "권위 있는 원본은 저널이고, JSON·SQLite·GUI는 언제든 다시 만들 수 있는 사본"이라는 뜻 — 사본은 절대 두 번째 진실원이 되지 않는다.

주변 언어 3종 (껍질)

언어맡은 일스택 상세
Rust부트스트랩·SDK·컴파일러6개 크레이트 워크스페이스. shifu(자립형 런처 바이너리) · trunk(제품 부트스트랩) · kungfu-sdk/kungfu-embedding(libkungfu Rust SDK) · xinfa(컨텍스트 컴파일러). 의존성 극단적으로 얇음(serde_json·sha2뿐).
Node/TSGUI·TUI·API·오케스트레이션pnpm 11 + lerna 9 + nx 모노레포. GUI = Electron 42 + React 18 + Vite, TUI = Ink 5 + React 18. 포맷/린트는 Biome. 계약 검증은 ajv(JSON Schema).
PythonCLI·네이티브 바인딩CPython 3.13(uv로 관리). C++ 코어 위의 CLI(framework/core/src/python/kungfu)·rewind·agent·skill·work. 런타임 의존: click·jsonschema·psutil·flatbuffers.
빌드 지휘shifu 3단 런처모든 명령의 단일 진입점. curl만 있으면 node(fnm)·python(uv)·툴체인을 스스로 부트스트랩. 218개 npm 스크립트가 전부 shifu 게이트를 통과해야 실행됨.
비유로 이해하기

Kungfu의 스택은 은행 금고와 그 주변 창구 같다. 금고(yijinjing 저널 + libkungfu)는 C++로 만든, 무엇도 새어나가지 않는 핵심 — 여기에 원본이 봉인된다. Rust는 금고를 여닫는 정밀 기계 장치(부트스트랩·SDK), Python은 창구 직원(사람이 명령을 내리는 CLI), Node/Electron은 로비의 전광판과 안내 데스크(GUI·TUI)다. 창구·전광판(JSON·SQLite·화면)이 보여주는 건 전부 금고 원장에서 다시 뽑아낼 수 있는 사본일 뿐, 금고 자체가 아니다.

4아키텍처 심화 분석

모든 것이 append-only 저널로 흐른다 — 그 위에 Fact·Episode·Trust 계층이 쌓인다

전체 구조를 한 문장으로: 맨 아래 yijinjing 저널이 유일한 진실원(원장), 그 위 libkungfu 런타임이 사실을 인정·봉인·검증하고, JSON·SQLite·GUI는 언제든 다시 만드는 투영(사본)이다. 아래가 그 층위다.

┌──────────────────────────────────────────────────────────────┐ │ 표면(껍질) GUI(Electron+React) · TUI(Ink) · kfx 뷰 확장 │ │ Python CLI(kungfu …) · Rust SDK · Node API │ └───────────────┬──────────────────────────────┬─────────────────┘ │ 바인딩(pybind11 / node-addon) │ (모두 사본을 읽음) ▼ ▼ ╔══════════════════════════════════════════════════════════════╗ ║ libkungfu 런타임 (사실을 인정·봉인·검증하는 곳) ║ ║ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ ║ ║ │ facts │ │ trust │ │ projection │ │ query │ ║ ║ │ (인정·봉인) │ │(Claim→증거)│ │(SQLite/GUI)│ │ (Cut 기준) │ ║ ║ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ ║ ║ │ recorded≠admitted≠trusted │ 재생성 가능 │ ║ ╚════════╪═════════════════════════════╪════════════════╪═══════╝ ▼ ▼ ▼ ┌──────────────────────────────────────────────────────────────┐ │ yijinjing = append-only mmap 저널 (유일한 원장 · 데이터 평면)│ │ [frame][frame][frame]… Hana POD(닫힘) + FlatBuffers(열림) │ │ ● 오직 뒤로만 붙는다 ● 나노초 타임스탬프 ● 유실·재현 보장 │ └──────────────────────────────────────────────────────────────┘ ▲ write │ replay / rewind │ "쓰기 반환 ≠ 보임 ≠ 영구 ≠ 투영" ▼ [에이전트/사람이 실제로 한 작업] [봉인된 Episode = sha256 머클 루트]

핵심 설계 ① — Fact와 Episode는 직교하는 두 축이다

Kungfu 사상의 중심에 이 구분이 있다. 헷갈리기 쉬운데, 둘은 경쟁하는 개념이 아니라 서로 다른 질문에 답하는 두 축이다.

Fact     ->  이 Cut(컷)에서 무엇이 인정되었는가   (지금의 스냅샷)
Episode  ->  여러 Cut에 걸쳐 무엇이 일어났는가       (시간의 흐름)

Fact는 "지금 이 순간 참으로 인정된 것들"의 집합이고, Episode는 "작업이 진행되며 벌어진 인과의 사슬"이다. 여기서 Cut이 결정적이다. Cut은 "이 질문에 답한 정확한 사실 경계"를 고정해, 3일 전에 던진 질문의 답을 오늘 다시 물어도 똑같이 재현되게 만든다. 시간이 흘러 사실이 바뀌어도, 특정 Cut에서의 답은 영원히 그대로다.

용어 — 저널 어휘 5종
Receipt · Watermark · Projection · Replay · Rewind
Receipt(영수증)는 "특정 위치 + 보장 수준"을 확인해 주는 타입 있는 확인서다. Watermark(워터마크)는 진행 경계인데 네 종류가 독립적이다 — 보임(visible)·영구(durable)·투영(projection)·복제(replicated). "썼다"와 "정말 디스크에 남았다"가 다르다는 걸 이 네 워터마크로 구분한다. Projection(투영)은 저널에서 다시 만들 수 있는 해석물(SQLite·GUI)로 두 번째 권위가 아니다. Replay(재생)는 같은 의미론으로 사실을 재구성하는 것, Rewind(되감기)는 검사용으로 다시 열되 부작용(side effect)은 재실행하지 않는 것이다.

핵심 설계 ② — 봉인된 에피소드는 진짜로 해시로 굳는다

추상 개념 같지만, 이 저장소의 .kungfu/ 안에는 실제로 봉인된 에피소드가 들어 있다. 아래는 실제 claims.jsonl의 한 조각이다(프레임 한 줄 = JSON 한 줄).

# .kungfu/episodes/sealed/sha256/<aa>/<full-hash>/claims.jsonl (실제 발췌)
{"index":0,"record":{"actor":"codex/pro-qian/dev-cache-scope-closure",
  "episode_id":202607170318,"record_kind":"episode_open",
  "schema":"kungfu.episode.manifest/v1","status":"open",
  "title":"Dev cache scope closure qualification",
  "begin_time":"1784258833068159208"}}          # ← 나노초 타임스탬프
{"index":2,"record":{"algorithm":"sha256","record_kind":"episode_root_committed",
  "root_value":"8367e64b1245a7c709187501a4592d2ea2044662a01312752ee7ce302caab4e9",
  "covered_record_count":2}}                     # ← 이 루트가 곧 봉인된 정체성

episode_open으로 열리고, 프레임들이 이어 붙고, 마지막에 episode_root_committedsha256 루트를 커밋하며 봉인된다. 이 루트 해시가 곧 에피소드의 콘텐츠 주소이자 변조 불가능한 정체성이다 — Git이 커밋을 해시로 굳히는 것과 똑같은 원리를, "에이전트가 한 작업"에 적용한 것이다.

핵심 설계 ③ — shifu: curl만으로 스스로 서는 단일 진입점

폴리글랏 모노레포의 악몽은 "빌드 환경 맞추기"다. Kungfu는 이를 shifu(師父, 스승)라는 3단 런처로 푼다. 신선한 클론에서 필요한 건 curl 하나뿐 — shifu가 node(fnm+.node-version)·python(uv)·툴체인(Buildchain)을 ~/.cache/kungfu에 알아서 부트스트랩한다. 그리고 218개 npm 스크립트가 전부 shifu 게이트를 통과해야만 실행된다(build조차 require-shifu.mjs를 먼저 지난다). "아무 명령이나 날것으로 도는" 일이 없다.

# 신선한 클론에서 소스 평가 — 이게 전부다
git clone https://github.com/kungfu-systems/kungfu.git
cd kungfu
./shifu doctor              # 환경 진단(스스로 부트스트랩)
./shifu sync && ./shifu build  # 의존성 동기화 + 빌드

# 불변식(Fact/Episode 규칙)을 소스에서 직접 캐묻기
./shifu invariant:verify -- --list --json
눈여겨볼 것 — 38개 게이트 × 6개 프로파일
계약(contract)으로 굴러가는 모노레포

shifu.gates.json38개 CI 게이트를 정의한다(21개가 qualification, 그 외 release·governance·docs·build). 각 게이트는 dev-pr·alpha-pr·release-pr6개 프로파일에서 필수/권고/끔으로 매핑된다. 게다가 framework/*/*.contract.json이 사실·에피소드·런타임의 규칙을 기계가 읽는 단일 진실원으로 두고, check:* 게이트가 그걸 검증한다. "문서로만 있는 규칙"이 아니라 CI가 강제하는 규칙이다.

핵심 설계 ④ — Xinfa: 검증된 컨텍스트 컴파일러

Xinfa(心法, 내공의 심법)는 "인간-에이전트 소프트웨어 개발을 위한 검증된 컨텍스트 컴파일러"다. 편리한 README나 낡은 요약, 추측한 경로가 슬그머니 "권위"가 되는 걸 막는 게 목표다. 선언된 프로젝트 소스에서 불변의 Atlas(지도)를 컴파일하고, 작업에 필요한 한정된 "Task Chart"만 골라 에이전트에게 준다. 각 에이전트 경로에는 측정된 토큰 예산이 붙는다(예: 문서 통제 66,560 · 코어 개발 16,384). 흐름은 compile → verify → route resolve → context. 실제로 이 저장소의 .xinfa/project.json이 그 컴파일된 노드·엣지·경로 그래프를 담고 있다.

핵심 설계 ⑤ — KFD 에이전트 공급망

가장 야심 찬 층위다. Kungfu는 자신을 "열린 에이전트 공급망"의 4번째 계층으로 규정한다.

KFD-3 발견  ->  Buildchain 아티팩트 증거  ->  KFD-2 평가
   ->  libkungfu / .kungfu 지속 작업 사실  ->  독립 Agent Hub들

발견(KFD-3)·검증 증거(Buildchain)·평가(KFD-2) 위에서, Kungfu는 "지속되는 작업 사실과 에피소드를 기록·정렬·질의·검증·수출·복구하는 4번째 층"을 맡는다. 그 위 독립 Agent Hub들은 서로 다른 제품이 소유하되, "책임 있는 작업 객체"를 표준 경계로 주고받는다. 각 수신자는 무엇을 받아들일지(admission)를 스스로 통제한다. 아직 대부분 "declared(선언)" 단계지만, "벤더가 달라도 작업 사실은 이식된다"는 방향성 자체가 이 프로젝트의 큰 그림이다.

5디렉토리 구조 해부

framework/core가 93MB로 압도적 — 나머지는 그 코어를 감싸는 층
kungfu/ ├── shifu, shifu.cmd, shifu.mjs ★ 3단 빌드 런처 (sh / bat / node) ├── shifu.gates.json 38개 CI 게이트 × 6개 프로파일 ├── toolchain.contract.json C++23/Ninja/Conan 컴파일러 정책 ├── docs.contract.json 필수 문서 + 상호링크 그래프 ├── package.json pnpm-workspace.yaml lerna.json ├── .node-version .uv-version .buildchain-version 툴체인 핀(고정 버전) │ ├── crates/ ★ Rust 워크스페이스 (초소형 정적 바이너리) │ ├── shifu, shifu-core 런처 + 부트스트랩/환경탐지 │ ├── trunk 제품 부트스트랩(dist/kungfu에 탑재) │ ├── kungfu-sdk, kungfu-embedding libkungfu Rust SDK / 안전 래퍼 │ └── xinfa 검증 컨텍스트 컴파일러(독립 제품) │ ├── framework/ ★ 93MB — 가장 큰 트리 │ ├── core/ ★★ C++ 코어 (전체의 51%) │ │ └── src/ │ │ ├── libyijinjing/ append-only mmap 저널 (데이터 평면) │ │ ├── libkungfu/ 런타임: facts/action/live/query/ │ │ │ trust/projection/state_cache … │ │ ├── bindings/{node,python}/ 네이티브 애드온 │ │ ├── python/kungfu/ 파이썬 CLI(cli·rewind·agent·skill·work) │ │ ├── slices/ fuzz/ 빌드 슬라이스 · 퍼징 │ │ └── .deps/hana-1.80.0/ 벤더링된 Boost.Hana(POD 스키마) │ ├── core api sdk agent-session gui 9개 TS/JS 패키지 │ │ tui kfx skill spec (GUI=Electron, TUI=Ink …) │ └── fact episode runtime action *.contract.json 단일 진실원 │ contract exit invariant … (check:* 게이트가 검증) │ ├── extensions/ ★ kfx 뷰 확장 시스템 │ │ fact/journal/rewind/terminal/ │ └── … work-dashboard 뷰 + mission-control + │ langchain 어댑터 ├── product/ @kungfu-tech/product-kungfu │ (데스크탑+CLI 도그푸드 조립체) ├── developer/sdk/ examples/ SDK · 예제(facts·opencode·probe-cpp/py) │ ├── .kungfu/ ★ 지속 Fact 저장소 (도그푸딩) │ ├── episodes/sealed/sha256/…/ 콘텐츠 주소로 봉인된 Episode │ │ (claims.jsonl + manifest.json + …) │ └── project-cuts/ ├── .xinfa/ ★ Xinfa Atlas 저장소 │ ├── project.json 컴파일된 노드·엣지·경로 그래프 │ └── submissions/ baselines/ manifests/ … │ ├── docs/ {adr,architecture,concepts, 방대한 문서 트리 │ guides,profiles,qualification} ├── scripts/ 272개 파일(262개 .mjs) — 게이트/빌드 도구 ├── tests/qualification/ config/ types/

구조가 말해 주는 것: 코어와 계약이 압도적 비중이다. framework/core(C++)가 심장이고, framework/*/*.contract.json 15개 폴더가 "규칙의 단일 진실원"으로 흩어져 있다. 껍질(GUI·TUI·CLI·SDK)은 이 코어를 각 언어로 감싼 얇은 층일 뿐이다. 그리고 숨김 폴더 .kungfu/·.xinfa/가 진짜 핵심 — 이 저장소가 자기 자신의 작업을 봉인된 에피소드와 검증된 Atlas로 남기며 스스로를 증거로 삼고 있다. 개념을 코드가 아니라 데이터로 증명하는 셈이다.

6학습 포인트

에이전트에 관심 없어도 훔쳐올, 분산 시스템·저장소 설계의 정석
배울 것 ①

append-only 저널 / 이벤트 소싱 — "상태 대신 사건을 저장한다"

yijinjing은 상태를 덮어쓰지 않고 일어난 사건을 뒤로만 이어 붙인다. 이것이 이벤트 소싱(event sourcing)·WAL(Write-Ahead Log)의 핵심이다. 현재 상태는 "사건을 처음부터 재생(replay)해 얻는 파생물"이 된다. Kafka·Datomic·Git·회계 원장이 전부 이 사상 위에 있다. "덮어쓰지 말고 이어 붙여라"는 한 문장이 감사 추적·재현성·시간 여행을 공짜로 준다.

배울 것 ②

콘텐츠 주소 지정 + 머클 루트로 "변조 불가능한 기록" 만들기

봉인된 에피소드는 sha256 루트로 굳는다. 내용이 1바이트라도 바뀌면 해시가 달라져 위조가 즉시 드러난다. Git·IPFS·블록체인이 쓰는 바로 그 기법을 "작업 기록"에 적용한 것. 데이터의 이름 = 데이터의 해시라는 발상을 이해하면, 캐시·중복제거·검증을 한 방에 푸는 사고 도구가 생긴다.

배울 것 ③

"기록됨 ≠ 신뢰됨" — 분산 시스템의 신뢰 경계 설계

recorded≠admitted≠trusted, 그리고 보임·영구·투영·복제의 4워터마크 분리는 분산 시스템 설계의 정수다. "쓰기가 반환됐다"와 "정말 디스크에 안전하다"는 다르다 — 이걸 뭉개면 데이터 유실이 난다. Kungfu는 이 경계를 타입과 영수증(Receipt)으로 강제한다. 데이터베이스·큐·스토리지를 다루는 누구에게나 값진 사고틀이다.

배울 것 ④

계약 기반 모노레포 — 규칙을 문서가 아니라 CI로 강제

218개 스크립트가 전부 게이트를 통과하고, 규칙은 *.contract.json이라는 기계가 읽는 단일 진실원에 산다. "이렇게 하기로 했다"는 합의가 README 구석의 문장이 아니라 CI가 막는 게이트로 존재한다. 팀이 커질수록 무너지는 "암묵적 규칙" 문제를, 계약을 코드화해 푸는 방법을 여기서 배운다.

배울 것 ⑤

자립형 폴리글랏 툴체인 — curl 하나로 서는 빌드

shifu는 node·python·rust 툴체인을 정확한 버전으로 스스로 부트스트랩한다. "내 컴퓨터에선 되는데"를 구조적으로 없애는 방법 — 버전 핀 파일(.node-version 등) + 자립형 런처 + 캐시 슬롯. 여러 언어가 섞인 프로젝트를 배포·온보딩할 때 그대로 훔쳐올 패턴이다.

실습 아이디어 (짧게)

클론한 저장소의 .kungfu/episodes/sealed/로 들어가 실제 claims.jsonlmanifest.json을 열어 봐라. episode_open → 프레임들 → episode_root_committed의 흐름을 눈으로 따라가고, 커밋된 root_value(sha256)가 어떻게 그 에피소드의 정체성이 되는지 확인하라. 개념 문서 100장보다 이 JSONL 몇 줄이 "봉인된 에피소드"를 더 확실히 각인시킨다.

7시스템 / 빌드 요구사항

쓰는 게 아니라 "빌드해서 평가한다" — 공개 릴리스는 아직 없다
항목요구사항 / 수치
설치 방법소스 빌드만 가능. 공개 릴리스 아티팩트 없음. git clone./shifu doctor./shifu sync && ./shifu build
부트스트랩신선한 클론에서 필요한 건 사실상 curl 하나. shifu가 node·python·툴체인을 ~/.cache/kungfu에 자동 설치
Node22.22.3 (fnm으로 .node-version 고정). 첫 파티 @kungfu-tech/libnode 사용
Python3.13 (>=3.13,<3.14), uv로 관리(.uv-version = 0.11.23)
C++ 툴체인C++23 · CMake ≥3.28 · Ninja ≥1.11 · Conan 2.29+. 컴파일러: macOS AppleClang 17+ / Linux GCC 14+ / Windows MSVC 19.40+
Rust워크스페이스(edition 2021). shifu 런처가 crates/shifu에서 소스로 빌드되거나 프리빌트를 내려받음
플랫폼macOS · Linux · Windows 지향. 단, "크로스플랫폼 증거는 아직 staged(미완)"라고 스스로 표기
상태v4.0.0-alpha · Coming soon. 강한 정전 내구성·기관용 프로파일 등은 미완으로 명시
주의 — 기대치 조정
"돌려서 써보는" 단계가 아니다

이건 brew install 한 방으로 쓰는 완제품이 아니다. C++23 툴체인 + Conan + Ninja가 필요한 소스 빌드 프로젝트이고, 빌드가 되더라도 공개 CLI는 "qualified(검증)" 전이라 동작이 바뀔 수 있다. 실무 도입용으로 지금 붙잡기보다는, 소스를 읽고 설계를 공부하는 용도로 접근하는 게 현실적이다. 실제로 이 문서도 "쓰는 법"이 아니라 "어떻게 설계됐나"에 무게를 뒀다.

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

개념 뜯어보기부터, 저널·콘텐츠주소·Atlas를 직접 미니 구현까지

과제 1. 봉인된 에피소드 해부하기 난이도 ★☆☆

저장소를 클론하고 .kungfu/episodes/sealed/sha256/ 아래의 실제 에피소드 폴더 하나를 열어라. claims.jsonl을 한 줄씩 읽으며 record_kindepisode_open→…→episode_root_committed로 흐르는 걸 따라가고, manifest.json과 대조하라. 목표: "에피소드 = 프레임들 + 그것을 봉인하는 sha256 루트"를 눈으로 확인.

과제 2. shifu 자립 부트스트랩 관찰 난이도 ★☆☆

./shifu doctor를 돌리고, shifu가 ~/.cache/kungfu에 node·python·툴체인을 어떻게 내려받아 세우는지 관찰하라. shifu.gates.json을 열어 38개 게이트 중 dev-pr 프로파일에서 required로 표시된 게 무엇인지 세어 보라. 목표: "curl만으로 서는 폴리글랏 빌드"가 실제로 어떻게 구성되는지 체감.

과제 3. 나만의 append-only mmap 저널 미니 구현 난이도 ★★☆

파이썬 mmap으로 "뒤로만 붙는" 로그를 짜라. 각 레코드에 나노초 타임스탬프를 붙이고, 오프셋으로 임의 읽기가 되게 하라. 그다음 "현재 상태"를 레코드 재생(replay)으로만 계산하라. 목표: yijinjing의 핵심 아이디어(상태 대신 사건, 재생으로 복원)를 손으로 재현.

과제 4. 콘텐츠 주소 에피소드 저장소 만들기 난이도 ★★★

과제 3의 로그 위에, 레코드 묶음을 sha256 머클 루트로 봉인하는 계층을 얹어라. 루트를 파일명으로 삼아 store/<aa>/<full-hash>/에 저장하고, 봉인 후 한 바이트만 바꿔도 검증이 실패하는지 확인하라. 목표: Git·IPFS식 "이름 = 해시" 저장소를 직접 만들어 변조 감지를 체험.

과제 5. Xinfa 흉내 — 프로젝트 소스에서 Atlas 컴파일 난이도 ★★★

작은 코드베이스를 스캔해 노드(문서/주장) + 엣지(의존) 그래프(Atlas)를 만들고, 각 노드에 콘텐츠 해시(revision)를 붙여라. 특정 "작업"에 필요한 최소 부분그래프(Task Chart)만 뽑되 토큰 예산 상한을 두고 잘라내라. 목표: "README를 통째로 먹이지 말고, 검증된 최소 컨텍스트만 준다"는 Xinfa 사상을 구현.

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

이 레포를 온전히 이해하려면 밟을 5주 코스
주차주제무엇을 · 왜
1주차이벤트 소싱 & append-only 로그WAL·이벤트 소싱·CQRS의 기초, "상태 대신 사건" 사상. Datomic·Kafka·회계 원장의 공통 원리를 잡고, 과제 3으로 미니 저널을 만든다.
2주차mmap & 저지연 IPC메모리 매핑 파일, 제로카피, 링버퍼(LMAX Disruptor), 나노초 타임스탬프. yijinjing이 왜 HFT에서 왔는지, POD 고정 레이아웃이 왜 빠른지 이해.
3주차콘텐츠 주소 저장소 & 머클sha256, 머클 트리, Git internals(blob/tree/commit), IPFS. 과제 4로 봉인·변조감지를 직접 구현하며 "이름 = 해시"를 체득.
4주차분산 신뢰 경계 & 내구성durability/visibility 워터마크, exactly-once의 환상, fsync·정전 안전성, admission control. recorded≠trusted가 왜 필요한지 사례로 학습.
5주차에이전트 컨텍스트 & 폴리글랏 빌드컨텍스트 엔지니어링(무엇을 넣고 뺄까), Xinfa식 검증 컨텍스트, 그리고 shifu식 자립 툴체인(fnm·uv·Conan)·계약 기반 CI. 과제 2·5로 마무리.

10핵심 키워드 사전

이 문서에 나온 개념들을 한 줄로
Kungfu (功夫)
에이전트 작업의 연속성을 위한 로컬 우선 런타임. "규율 있는 수련으로 얻는 역량"에서 딴 이름. 재귀 약어이기도: KUNGFU = Never Guess. Facts Unfold.
Fact (사실)
특정 Cut에서 참으로 "인정된" 타입 있는 진술. 저널이 권위 있는 원본이고, 투영(JSON·SQLite)은 이것에서 다시 만든다.
Episode (에피소드)
실제로 벌어진 작업의 인과 단위 — 사실·산출물·의존성·영수증·검증뿌리를 묶은 것. 채팅 세션도 프로세스도 로그 뭉치도 아니다.
Cut (컷)
"이 질문에 답한 정확한 사실 경계". 과거의 답을 시간이 지나도 그대로 재현 가능하게 만든다.
Watermark (워터마크)
진행 경계. 보임·영구·투영·복제 네 종류가 독립적. "썼다"와 "정말 안전하다"를 구분하는 장치.
Projection (투영)
저널에서 다시 만들 수 있는 해석물(SQLite·GUI). 편리한 사본일 뿐 두 번째 권위가 아니다.
Replay / Rewind
재생은 같은 의미론으로 사실을 재구성. 되감기는 검사용으로 다시 열되 부작용(side effect)은 재실행하지 않음.
TrustReport (신뢰 보고서)
Claim + Purpose + Cut + Proof로 만들어지는 판정. 에이전트의 자기 주장은 스스로를 승인할 수 없다.
yijinjing (易筋经)
C++ append-only mmap 저널 = 데이터 평면. 원래 HFT용으로, 유실 없이 재현 가능한 나노초 기록이 목표.
libkungfu
저널 위의 런타임. Facts·Episodes·Cuts·Projections·TrustReport를 실제로 구현하는 C++ 계층.
shifu (師父)
3단 빌드 런처이자 단일 진입점. curl만으로 node·python·툴체인을 부트스트랩. 218개 스크립트가 모두 이 게이트를 통과.
Xinfa (心法)
검증된 컨텍스트 컴파일러. 선언된 소스에서 불변 Atlas를 컴파일해, 토큰 예산이 매겨진 최소 Task Chart만 에이전트에 준다.
KFD 에이전트 공급망
발견(KFD-3)→Buildchain 증거→평가(KFD-2)→libkungfu 작업 사실→독립 Agent Hub로 이어지는 이식 표준 구상. Kungfu는 4번째 층.
kfx (Kungfu eXtension)
Fact 라이브러리·저널 관리·Rewind 검사·터미널 등 뷰 확장 시스템. GUI/TUI가 이 확장들로 조립된다.
Hana POD / FlatBuffers
닫힌 커널 레코드는 Boost.Hana 고정 레이아웃 POD(제로카피), 열린 도메인 Fact는 FlatBuffers. JSON은 가장자리 투영뿐.

11참고 링크

원문으로 더 파고들기