유행레포 딥다이브 · tvytlx/ai-agent-deep-dive 분석

AI Agent 딥다이브
— ~500줄 Python으로 까보는 코딩 에이전트의 속

Claude Code·Cursor·OpenAI Codex 같은 코딩 에이전트가 내부에서 어떻게 도는지를, 교육용 Python 에이전트(485줄) + 17편의 설계 문서로 통째로 해부한 학습 레포. 핵심 결론은 단순하다 — "에이전트는 결국 while 루프 하나, 그 위에 9개 층이 쌓였을 뿐". (저장소: tvytlx/ai-agent-deep-dive · ⭐5.8k · 🍴1.6k · Python 100% · Poetry)
목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가
  3. 기술 스택 · 구성 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 구조 해부
  6. 학습 포인트 (주제별)
  7. 시스템 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

이 레포가 정확히 무엇을 보여주는가

ai-agent-deep-dive프로덕션급 AI 에이전트(Claude Code류)를 역설계해, 핵심 원리만 남긴 교육용 미니 에이전트와 17편의 설계 문서로 정리한 학습 레포다. "코딩 에이전트가 마법처럼 코드를 고치는데, 안에서 뭐가 도는 거지?"라는 궁금증에 코드로 답한다.

한 컷 비유

"에이전트는 결국 while 루프다.
그 루프 위에 9개의 층이 쌓여 있을 뿐."

복잡해 보이는 Claude Code도 본질은 단순한 반복문 하나다. LLM에게 질문하고 → 도구를 호출하고 → 결과를 받아 → 다시 LLM에게 보낸다. 끝날 때까지. 이 골격 위에 메모리 관리·권한·검증 에이전트·컨텍스트 압축 같은 9개의 층을 쌓아올린 게 프로덕션 에이전트다.

이 레포는 그 9개 층을 차례로 해부한 역설계 보고서 + 동작하는 Python 코드(src/agt/)다. 챗봇과 에이전트의 차이를 한 줄로 — 챗봇은 말만 하지만, 에이전트는 일을 한다.

용어
AI 에이전트 (Agent)
LLM(대규모 언어 모델)에 도구를 쓸 수 있는 능력을 붙인 시스템. 사람이 일일이 안 시켜도 스스로 다음 단계를 정한다. "생각 → 행동 → 결과 관찰 → 다시 생각"을 반복하는 while 루프가 본체다.

2왜 주목받는가

학습 레포가 ⭐5.8k를 모은 이유
기존 학습의 불편함
"에이전트 만들어봐" → 막상 코드를 열면 수만 줄 + 프레임워크 미궁

실제 Claude Code·Cursor는 비공개거나 거대해서 초보가 읽을 수 없다. LangChain 같은 프레임워크는 추상화가 두꺼워 "그래서 루프가 어디 있지?"가 안 보인다. 정작 에이전트가 내부에서 어떻게 도는지 평이하게 알려주는 자료가 드물었다.

이 레포의 해법
"읽을 수 있는 크기"로 줄인 에이전트 — 코드 + 설계서 둘 다

핵심 로직을 Python ~500줄(교육용 주석 포함 485줄)로 압축하고(src/agt/agent.py), FakeLLM 인터페이스로 API 키 없이도 돌려볼 수 있게 했다. 거기에 요구사항 명세 스타일의 17편 문서(docs/00~16)로 "왜 이렇게 설계했는지"까지 붙였다. 코드와 설계 의도를 같이 주는 게 핵심.

비슷한 학습 자료와의 차이

비교 대상이 레포의 위치
실제 Claude Code / Cursor읽기엔 너무 크고 비공개. 이 레포는 같은 패턴을 축소 모델로 보여줌
LangChain / LlamaIndex프레임워크는 추상화가 두껍다. 여기는 프레임워크 없이 맨손 while 루프라 골격이 드러남
블로그 글 "에이전트란"글은 개념만. 이 레포는 실행되는 코드 + 설계 명세서로 손에 잡힘
논문 (ReAct 등)이론. 이 레포는 그 이론을 Python ~500줄(교육용 주석 포함 485줄)로 구현해 체득시킴
자동차 비유

실제 양산차 엔진은 뜯어보기 너무 복잡하다. 이 레포는 투명 케이스에 담긴 1기통 데모 엔진 같다 — 실린더 하나가 어떻게 폭발해서 바퀴를 돌리는지 눈으로 따라갈 수 있다.

원리를 잡고 나면, 12기통 양산차(Claude Code)를 봐도 "아, 이게 그거 여러 개구나"가 보인다.

3기술 스택 · 구성 지도

언어 구성 · 런타임 · 의존성 관리 · 구성 요소

언어 구성

Python ████████████████████████████████ 100% ← 교육용이라 단일 언어로 단순화

의도적으로 Python 단일 언어다. 학습 대상이 "에이전트의 구조"이지 "다양한 스택"이 아니므로, 곁가지를 쳐냈다.

런타임 / 핵심 구성

기술역할상세
Python 3구현 언어전체 코드가 Python. 타입 힌트 + Protocol 적극 사용
Poetry의존성 관리pyproject.toml + poetry.lock. pip 아님 — poetry install로 설치
FakeLLM 인터페이스모델 자리표시자실제 API 없이 정해진 답을 스트리밍으로 반환. 나중에 진짜 LLM으로 교체
agt CLI실행 진입점poetry run agt "..."로 에이전트 실행. src/agt/cli.py
Skills 디스커버리능력 확장--skills-dir로 스킬 폴더 지정, --list-skills로 목록 확인

레포가 다루는 "능력 확장 3축" (개념)

역할한 줄 정의
Skill절차/지식 패키지SKILL.md 한 장으로 "이 작업은 이렇게 해"를 가르침
Plugin묶음 배포 단위여러 스킬·커맨드·설정을 한 번에 설치/제거 (npm 패키지처럼)
MCP외부 연결 표준Slack·GitHub·DB 등을 잇는 "AI용 USB 포트" 프로토콜

설계 문서로 다루는 9계층 (개념 지도)

분류대응 문서
토대진입점 · 프롬프트 편성 · 도구 실행00 · 01 · 02
두뇌확장 생태계(Skills/Plugins/MCP) · 메모리·세션 · 아키텍처 맵03 · 04 · 07
운영태스크·백그라운드 · 품질 보증 · 운영자 경험05 · 06 · 11~14

4아키텍처 심화 분석

while 루프 · Protocol 플러그형 설계 · 컨텍스트 관리 · 검증 에이전트

전체 구조도 — while 루프 위에 쌓은 9계층

┌─────────────────────────────────────────────────────────────┐ │ 9층 운영자 경험 TUI 화면 · 상태바 · 권한 프롬프트 · 진행률 │ ├─────────────────────────────────────────────────────────────┤ │ 8층 품질 보증 검증 에이전트 → build/test/lint → PASS/FAIL│ ├─────────────────────────────────────────────────────────────┤ │ 7층 태스크/백그라운드 로컬·백그라운드·원격 태스크, 셸 실행 │ ├─────────────────────────────────────────────────────────────┤ │ 6층 메모리 & 세션 프로젝트/유저 메모리, 세션 요약 (CLAUDE.md) │ ├─────────────────────────────────────────────────────────────┤ │ 5층 확장 생태계 Skills · Plugins · MCP (능력 확장 3축) │ ├─────────────────────────────────────────────────────────────┤ │ 4층 에이전트 스케줄링 자식 에이전트 spawn, 생명주기 관리 │ ├─────────────────────────────────────────────────────────────┤ │ 3층 도구 실행 도구 발견 · 입력검증 · 권한 · hook · 로깅 │ ├─────────────────────────────────────────────────────────────┤ │ 2층 프롬프트 편성 시스템 프롬프트 + 환경정보 + 메모리 규칙 │ ├─────────────────────────────────────────────────────────────┤ │ 1층 진입점 CLI · SDK · MCP 인터페이스 │ └─────────────────────────────────────────────────────────────┘ ▲ 위로 갈수록 "운영", 아래로 갈수록 "토대" 모든 층의 심장 = 1~3층을 도는 단 하나의 while 루프

핵심 설계 패턴 ①: 단순한 while 루프 (에이전트의 심장)

패턴
Agent Loop (생각 → 행동 → 관찰의 반복)
LLM에게 이력 전체를 보내 응답을 받고, 그게 도구 호출이면 실행해 결과를 다시 이력에 넣고 또 보낸다. 일반 메시지가 나오거나 max_turns를 넘으면 종료. src/agt/agent.pyAgent.run()이 바로 이것.
while True: # 에이전트의 본체 reply = llm(history) # 1. 전체 이력을 LLM에 전달 if reply.is_plain_text: # 2. 그냥 답이면 return reply # → 종료 result = run_tool(reply.tool) # 3. 도구 호출이면 실행 history.append(result) # 4. 결과를 이력에 추가 if turns > max_turns: # 5. 너무 오래 돌면 break # → 강제 종료
요리사 비유

에이전트는 새 요리에 도전하는 요리사 같다. 레시피 한 줄을 읽고(생각), 재료를 자르고(행동), 맛을 보고(관찰), 다음 단계를 정한다(다시 생각). 맛이 이상하면 재시도, 좋으면 다음으로.

이 단순한 반복이 복잡한 요리를 완성하듯, while 루프가 리팩토링·디버깅 같은 복잡한 작업을 해낸다.

핵심 설계 패턴 ②: Protocol 기반 "플러그를 꽂으면 되는" 설계

용어
Protocol (프로토콜 = 약속된 인터페이스)
Python에서 "이런 메서드를 가진 객체"라고 약속하는 방법. Java의 interface와 비슷한데 상속을 안 해도 모양만 맞으면 동작한다. 이를 통해 의존성 역전(코어가 구현체를 모름)이 된다.
콘센트 비유

벽 콘센트는 정해진 모양이다. 그 모양만 맞으면 충전기든 주전자든 다 꽂힌다. 콘센트는 안에 뭐가 꽂힐지 모르고, 신경도 안 쓴다.

Agent 코어가 콘센트라면 LLM 클라이언트는 플러그다. OpenAI든 Anthropic이든 로컬 Ollama든 — stream_text() 같은 메서드만 있으면 끼울 수 있다.

왜 중요한가
테스트와 교체를 한 번에 해결

실제 LLM 없이 테스트된다. FakeLLMClient가 정해진 답만 반환하면 네트워크·API 키 없이 로직 검증 가능 — 비용도 응답 시간도 0. 나중에 진짜 LLM으로 바꿀 때 Agent 코드는 한 줄도 안 건드리고 클라이언트만 교체한다.

핵심 설계 패턴 ③: LLM의 "기억상실"을 막는 컨텍스트 관리

용어
Context Window (컨텍스트 윈도우)
LLM이 한 번에 볼 수 있는 텍스트의 최대 길이(토큰 수로 잼). 책 한 권 분량이지만, 큰 프로젝트를 다루면 금방 차버린다. 차면 앞부분을 잊는다 — 모델이 게을러서가 아니라 구조적 한계다.
함정
"윈도우만 크면 된다"는 착각

윈도우가 커져도 긴 컨텍스트일수록 집중력이 떨어진다("lost in the middle"). 중간 정보를 무시하기 시작하고, 비용도 토큰 수에 비례해 늘어난다.

해결책
3단계 컨텍스트 압축

Level 1 경량 트리밍: 중복 진행 표시·과한 도구 출력을 잘라낸다.

Level 2 요약: 오래된 메시지를 "사용자가 X 요청 → Y, Z 단계 거침" 식 한 단락으로 압축.

Level 3 경계 마킹: 압축 지점에 표식을 남기고 정말 중요한 것(현재 목표·안전 규칙·사용자 선호)만 남긴다.

핵심 설계 패턴 ④: AI가 AI를 검증한다 — 검증 에이전트

함정
자기 자신을 채점하는 학생

같은 LLM에게 "방금 한 거 잘했어?"라고 물으면 대개 "네"라고 한다. 객관적 검증이 안 된다. 그대로 두면 컴파일도 안 되는 코드를 자랑스럽게 보고한다.

해결책
별도의 검증 에이전트

작업 에이전트와 분리된 검증 에이전트를 둔다. 그의 일은 하나 — build·test·lint 실행 후 PASS/FAIL 판정. 작업 에이전트의 자기 평가는 무시. FAIL이면 결과를 돌려보내 재시도시킨다. 장애 복구도 같은 사상(멱등성: 같은 작업을 두 번 해도 결과가 같게 설계)이다.

5디렉토리 구조 해부

코드는 src/agt, 설계 의도는 docs
tvytlx/ai-agent-deep-dive/ ├── src/agt/ # ⭐ 핵심 — 동작하는 미니 에이전트 │ ├── agent.py # 메인 while 루프 (Message·Tool·Agent 세 클래스) │ └── cli.py # CLI 진입점 → `agt "..."` 명령 ├── docs/ # ⭐ 17편 설계 문서 (요구사항 명세 스타일) │ ├── 00-product-overview.md # 제품 포지셔닝·핵심 사용자 │ ├── 01-system-prompt-and-orchestration.md # 시스템 프롬프트·역할 편성 │ ├── 02-tools-permissions-and-execution.md # 도구·권한·실행 체인·보안 │ ├── 03-skills-plugins-mcp.md # 능력 확장 3축 │ ├── 04-memory-and-session.md # 메모리·세션·압축·복구 │ ├── 05-commands-ui-and-operator-experience.md # 커맨드·TUI·상태표시 │ ├── 06-verification-and-quality.md # 검증 에이전트·품질 보증 │ ├── 07-architecture-map.md # ⭐ 9계층 아키텍처 맵 │ ├── 08-agent-runtime-loop.md # ⭐ 메인 루프 명세 │ ├── 09-message-model-and-state.md # 메시지 구조·세션 상태 │ ├── 10-context-management.md # ⭐ 컨텍스트 압축·복구 │ ├── 11-task-model.md # 태스크 모델·백그라운드 │ ├── 12-workspace-and-isolation.md # 워크스페이스 격리·권한 경계 │ ├── 13-failure-recovery.md # 장애 복구 │ ├── 14-configuration-system.md # 설정 소스·우선순위 │ ├── 15-mvp-scope.md # Python MVP 범위 │ └── 16-python-implementation-notes.md # 구현 가이드·모듈 구조 ├── tests/ # 테스트 (FakeLLM 덕에 API 없이 검증) ├── .github/workflows/ # CI ├── pyproject.toml # Poetry 의존성 정의 └── poetry.lock # 잠금 파일

읽는 순서 힌트: 먼저 src/agt/agent.py 한 파일로 골격을 잡고 → docs/07(9계층 맵)·08(루프)·10(컨텍스트) 세 편으로 "왜 그렇게 설계했나"를 채우면, 나머지 문서는 곁가지로 빠르게 읽힌다.

읽을 때 주의
docs는 "코드 주석"이 아니라 "요구사항 명세"

docs/ 문서들은 코드를 줄별로 설명하는 게 아니라, 프로덕션 에이전트가 갖춰야 할 요구사항을 모듈별로 정리한 스펙에 가깝다. 그래서 일부 항목(원격 태스크·백그라운드 에이전트 등)은 미니 코드에는 아직 없고 "이렇게 해야 한다"는 설계 의도로만 존재할 수 있다 — 코드와 1:1로 매칭하려 들지 말 것.

6학습 포인트 (주제별)

이 레포에서 무엇을 배울 수 있는가

A. 에이전트의 본질 — while 루프

배울 것: 화려한 기능을 다 걷어내면 에이전트는 "생각→행동→관찰"의 반복문 하나라는 사실. Message(대화 단위)·Tool(도구)·Agent(루프) 세 클래스의 관계만 잡으면, 이후 어떤 에이전트 코드도 무섭지 않다.

B. Protocol로 LLM을 갈아끼우는 의존성 역전

배울 것: 코어가 구현체를 모르게 만드는 설계. FakeLLM ↔ 실제 LLM 교체가 코드 한 줄 안 바꾸고 되는 이유. 테스트 용이성과 교체 가능성을 동시에 얻는 실전 예제다.

C. 컨텍스트 관리 — 긴 대화를 버티는 법

배울 것: 트리밍 → 요약 → 경계 마킹의 3단계 압축. "윈도우만 키우면 된다"가 왜 함정인지("lost in the middle", 비용 폭증)와, 토큰 예산을 관리하는 사고법.

D. 능력 확장 3축 — Skill / Plugin / MCP

배울 것: 셋이 어떻게 다른지. Skill(절차서) ⊂ Plugin(묶음 배포) / MCP(외부 연결 표준)의 역할 분담. --skills-dir·--list-skills로 스킬 디스커버리를 직접 만져볼 수 있다.

E. 검증 에이전트 — AI가 AI를 채점

배울 것: 자기 검증의 함정과, 별도 검증 에이전트로 build/test/lint를 돌려 객관적 PASS/FAIL을 내는 패턴. 멀티 에이전트의 가장 실용적인 첫걸음.

F. 9계층으로 보는 "프로덕션 에이전트의 지도"

배울 것: 진입점·프롬프트·도구·스케줄링·확장·메모리·태스크·품질·운영자경험의 9층. 각 층이 레고처럼 독립 모듈이라, 1~3층만 먼저 짜고 위로 쌓는 식으로 미니 Claude Code를 단계적으로 만들 수 있다.

7시스템 요구사항

실행에 필요한 것 (가볍다)
항목최소권장
OSmacOS / Linux / Windows (어디든)상관없음 (순수 Python)
Python3.11+ (pyproject.toml: >=3.11,<4.0)3.11+
패키지 관리PoetryPoetry 최신
RAM1GB (FakeLLM은 추론 안 함)2GB+
네트워크불필요 (FakeLLM이면 오프라인 OK)실제 LLM 연결 시에만 필요
API 키불필요 (기본 FakeLLM)실제 LLM 교체 시 OpenAI/Anthropic 키
진입 장벽이 낮은 이유
GPU도, API 키도, 인터넷도 없이 시작

FakeLLM이 정해진 응답을 스트리밍으로 흉내내기 때문에, 설치만 하면 바로 루프가 도는 걸 볼 수 있다. 학습 비용이 0에 수렴한다.

실행 명령

# 1. 의존성 설치 (Poetry)
poetry install

# 2. 에이전트 실행 (FakeLLM이라 키 불필요)
poetry run agt "你好"

# 3. 스킬 목록 확인
poetry run agt --skills-dir ./skills --list-skills

※ 저자가 중국어권이라 예제에 "你好"(안녕)가 쓰인다. 한국어/영어 입력으로 바꿔도 동일하게 동작한다.

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

난이도별 5가지 과제
과제 1

agent.py 코드 정독하기 ★ 초급 30분

git clonesrc/agt/agent.py 하나만 끝까지 읽는다(교육용 주석 포함 485줄, 핵심 로직은 그보다 적음). Message·Tool·Agent 세 클래스의 관계와 while 루프의 종료 조건을 그림으로 그려본다.

확인 포인트: (1) 루프가 어디서 시작/끝나는가 (2) 도구 호출 결과가 어떻게 이력에 다시 들어가는가 (3) max_turns는 어디서 검사되는가
과제 2

설치하고 FakeLLM 루프 돌려보기 ★ 초급 30분

# 설치 후 바로 실행 (키 불필요)
poetry install
poetry run agt "파일 목록 보여줘"

# 스킬 디스커버리 체험
poetry run agt --skills-dir ./skills --list-skills

FakeLLM이 반환하는 가짜 응답이 루프를 어떻게 한 바퀴 돌리는지 콘솔 출력으로 관찰한다.

과제 3

파일 읽기/쓰기 도구 추가 ★★ 중급 2시간

read_file_tool, write_file_tool을 직접 정의해 도구 레지스트리에 등록한다. LLM이 tool_call을 어떻게 파싱하고 결과를 메시지에 되먹이는지 체득한다.

구현: (1) Tool 인터페이스(name·description·run)에 맞춰 함수 작성 (2) 에이전트에 등록 (3) FakeLLM이 그 도구를 호출하도록 응답 시나리오 수정 → 루프가 파일을 실제로 건드리는지 확인
과제 4

FakeLLM을 실제 OpenAI로 교체 ★★★ 고급 3시간

Protocol 패턴의 위력을 체감하는 핵심 과제. FakeLLMClient 자리에 OpenAI API를 호출하는 OpenAIClient를 만들어 끼운다. Agent 코드는 한 줄도 안 바꾼다.

# openai_client.py — Protocol만 맞추면 끝
class OpenAIClient:
    def stream_text(self, history):
        # OpenAI ChatCompletion 스트리밍 호출
        for chunk in openai_stream(history):
            yield chunk
과제 5

검증 에이전트 + 작업 에이전트 페어 만들기 ★★★ 고급 4시간

멀티 에이전트의 가장 단순한 형태. 작업 에이전트가 코드를 수정하면, 검증 에이전트가 pytest를 돌려 결과를 돌려준다. FAIL이면 피드백 후 재시도. 이걸 만들면 멀티 에이전트의 본질을 잡는다.

설계: 작업 에이전트(코드 생성) → 검증 에이전트(pytest 실행, PASS/FAIL만 판정) → FAIL이면 에러 메시지를 작업 에이전트 이력에 추가하고 루프 재진입. docs/06을 참고.

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

4주 학습 플랜 — 1~3층부터 9층까지 쌓아 올리기

1주차: 골격 잡기 (코드 + 루프)

요일학습 내용실습
레포 클론 & 설치poetry installagt 실행
agent.py 정독Message·Tool·Agent 클래스 관계도 그리기
while 루프 추적docs/08 루프 명세와 코드 대조
메시지 모델docs/09 — 대화 상태가 어떻게 쌓이나
FakeLLM 이해가짜 응답이 루프를 도는 과정 디버깅

2주차: 도구 & Protocol (3층)

요일학습 내용실습
도구 시스템 개념docs/02 — 도구·권한·실행 체인
커스텀 도구 작성read_file/write_file 도구 추가
Protocol 의존성 역전FakeLLM ↔ 실제 LLM 인터페이스 비교
OpenAI 클라이언트 교체OpenAIClient 만들어 끼우기
권한 & 보안docs/02 권한 모델 정리

3주차: 메모리 · 컨텍스트 · 확장 (5~6층)

요일학습 내용실습
컨텍스트 압축docs/10 — 3단계 압축 구현 스케치
메모리 & 세션docs/04 — 세션 요약·복구
Skill 디스커버리--skills-dir로 스킬 추가/조회
Plugin vs MCPdocs/03 — 3축 차이 정리
설정 시스템docs/14 — 설정 소스·우선순위

4주차: 멀티 에이전트 · 품질 · 운영 (4·8·9층)

요일학습 내용실습
에이전트 스케줄링docs/01 역할 편성 + 자식 에이전트
검증 에이전트docs/06 — pytest 검증 페어 구현
장애 복구 & 멱등성docs/13 — 세션 트랜스크립트 복구
워크스페이스 격리docs/12 — 작업 격리 경계
종합 — 미니 Claude Code9계층 중 1~6층을 결합한 작은 에이전트 완성

10핵심 키워드 사전

이 레포를 이해하는 데 꼭 필요한 용어들
키워드설명
AI 에이전트LLM에 도구 사용 능력을 붙여 스스로 다음 단계를 정하는 시스템. 챗봇은 말만, 에이전트는 일을 한다
Agent Loop"생각→행동→관찰"을 반복하는 while 루프. 에이전트의 본체
Tool CallingLLM이 "이 도구를 이 인자로 실행"이라 요청하는 것. 에이전트가 세상과 상호작용하는 유일한 통로
Protocol"이런 메서드를 가진 객체"라는 약속. 상속 없이 모양만 맞으면 끼워지는 인터페이스
의존성 역전코어가 구현체를 모르게 만드는 설계. LLM 교체가 코드 변경 없이 되는 이유
FakeLLM실제 모델 대신 정해진 답을 스트리밍으로 반환하는 테스트용 클라이언트. API 키·비용 0
Context WindowLLM이 한 번에 볼 수 있는 텍스트 최대 길이(토큰 단위). 차면 앞부분을 잊는다
컨텍스트 압축트리밍→요약→경계 마킹 3단계로 토큰 예산을 관리해 긴 대화를 버티는 기법
lost in the middle컨텍스트가 길수록 중간 정보를 무시하는 LLM의 집중력 저하 현상
SkillSKILL.md 한 장으로 "이 작업은 이렇게 해"를 가르치는 절차서
Plugin여러 스킬·커맨드·설정을 한 묶음으로 배포하는 단위 (npm 패키지처럼)
MCPModel Context Protocol. 외부 서비스를 잇는 "AI용 USB 포트" 표준
검증 에이전트작업 에이전트와 분리되어 build/test/lint로 객관적 PASS/FAIL을 내는 에이전트
멱등성같은 작업을 두 번 해도 결과가 같게 설계하는 것. 장애 복구의 토대
9계층 아키텍처진입점·프롬프트·도구·스케줄링·확장·메모리·태스크·품질·운영자경험의 모듈 지도
max_turns에이전트 루프가 무한 반복하지 않도록 거는 최대 반복 횟수 안전장치
PoetryPython 의존성·패키징 도구. pyproject.toml+poetry.lock으로 환경 재현
스킬 디스커버리--skills-dir로 지정한 폴더에서 스킬을 자동 탐색·목록화하는 메커니즘

11참고 링크

더 깊이 파고들 때 유용한 자료들