기존 서브에이전트: 호출 → 결과 반환 → 즉시 소멸 (일회성)
Agent Teams:      소환 → 상주 → 메시지 교환 → 자율 작업 → shutdown 시 종료

사용자: "ISSUE-011 해결해줘"

[실제 동작]
메인 클로드가 직접:
  1. 코드 분석 (RAG 역할)
  2. 코드 수정 (Backend 역할)
  3. Frontend 수정 (Frontend 역할)
  4. 테스트 (QA 역할)
  5. Slack 알림 (PM 역할)
→ 1명이 5개 역할을 순차 수행

사용자: "ISSUE-011 해결해줘"

[Agent Teams 동작]
Lead (클로드):
  → TaskCreate("entity_name 추출 로직 수정", owner: RAG)
  → TaskCreate("Graph 패널 entity 표시", owner: Frontend, blockedBy: #1)
  → TaskCreate("E2E 검증", owner: QA, blockedBy: #1, #2)

RAG: TaskList 확인 → #1 claim → 코드 수정 → completed
  → SendMessage(Frontend, "entity_name 수정 완료, API 스펙 확인해줘")

Frontend: 메시지 수신 → 깨어남 → #2 claim → UI 수정 → completed
  → SendMessage(QA, "프론트엔드 수정 완료, 검증 가능")

QA: 메시지 수신 → 깨어남 → #3 claim → E2E 테스트 → completed
  → SendMessage(Lead, "전체 PASS, ISSUE-011 해결됨")

Lead: Slack 알림, 최종 보고

[개별 위임 (Task Tool)]
Main Claude ─→ Task(RAG, "ISSUE-011 수정") ─→ 결과 반환 ─→ 소멸
             ─→ Task(DevOps, "매뉴얼 작성")  ─→ 결과 반환 ─→ 소멸
             (각 에이전트는 독립적, 서로 모름)

[Agent Teams (TeamCreate)]
Main Claude ─→ TeamCreate("sprint-08")
             ─→ Task(RAG, team_name: "sprint-08")   ─→ 상주 (idle/active)
             ─→ Task(Frontend, team_name: "sprint-08") ─→ 상주 (idle/active)
             ─→ Task(QA, team_name: "sprint-08")     ─→ 상주 (idle/active)
             (팀원 간 SendMessage 가능, 공유 TaskList)

TeamCreate("hrkp-sprint-08")
├── RAG Agent: ISSUE-011 entity_name 수정 + Graph Search 튜닝
├── Frontend Agent: Graph 패널 UX 개선
├── Backend Agent: Gateway 라우팅 검증 스크립트
└── QA Agent: E2E 테스트 54건 작성
→ 5개 태스크, 의존성 있음, 장시간 협업, 팀원 간 소통 활발
→ 결과: 5/5 완료, ISSUE-011 해결

Task(DevOps, "BuildKit 빌드 가이드 작성")  → 독립 문서 작업
Task(Infra, "UAT 준비 상태 점검")           → 독립 점검 작업
→ 서로 의존 없는 2개 독립 작업, 팀 구성 불필요
→ 결과: 둘 다 완료 (빠르고 효율적)

[개별 위임의 비용 구조]
  Task 호출 → 작업 수행 → 결과 반환 → 종료
  과금: 작업 시간만 (idle 비용 없음)
  적합: 10분 미만 단발 작업

[Agent Teams의 비용 구조]
  TeamCreate → 팀원 소환 → 작업 수행 → idle 대기 → 추가 작업 → shutdown
  과금: 작업 시간 + idle 대기 시간 (idle은 API 비용 없으나 프로세스 유지)
  적합: 여러 태스크를 30분+ 연속 처리할 때

[혼합 전략 (권장)]
  Sprint 메인 작업 → Agent Teams (팀 협업)
  독립 부가 작업 → 개별 위임 (빠른 처리)
  문서/점검 → 개별 위임 (단발 완결)

# 팀원 소환 (Lead가 실행)
Task(
  subagent_type = "rag-engineer",      # .claude/agents/ 에이전트 타입
  team_name     = "hrkp-sprint-08",    # 팀 이름
  name          = "rag",               # 팀원 이름 (SendMessage에서 사용)
  prompt        = "Sprint 08 RAG Engineer입니다. TaskList를 확인하고 작업을 시작하세요.",
  mode          = "bypassPermissions"  # 또는 "default"
)

# 모델 지정 소환 (기본값: 에이전트 파일의 model 설정 사용)
Task(
  subagent_type = "backend-developer",
  team_name     = "hrkp-sprint-08",
  name          = "backend",
  model         = "sonnet",            # claude-sonnet-4-6 (기본 설정)
  prompt        = "..."
)

1. TaskList 확인
2. owner가 자신이거나 미할당 + blockedBy 없는 태스크 찾기
3. TaskUpdate(owner: 자신, status: in_progress)
4. 작업 수행
5. TaskUpdate(status: completed)
6. SendMessage(Lead, "완료 보고")
7. TaskList 다시 확인 → 다음 태스크 있으면 반복
8. 없으면 idle 상태로 대기

Lead → TaskCreate(#1 entity_name 수정, owner: RAG)
Lead → TaskCreate(#2 Graph UI, owner: Frontend, blockedBy: #1)
Lead → TaskCreate(#3 E2E 검증, owner: QA, blockedBy: #1,#2)

Lead → Task(rag-engineer, team: hrkp-sprint-08, name: "rag")
Lead → Task(frontend-developer, team: hrkp-sprint-08, name: "frontend")
Lead → Task(qa-engineer, team: hrkp-sprint-08, name: "qa")

RAG → entity_name 로직 수정 → SendMessage(Frontend)
Frontend → Graph UI 수정 → SendMessage(QA)
QA → E2E 테스트 → SendMessage(Lead, "ALL PASS")

Lead → 태스크 분할 (DB → Backend → Frontend → QA)
Lead → 4명 소환 (db, backend, frontend, qa)

DB: 스키마 설계 → completed → SendMessage(Backend, "스키마 완료")
Backend: API 구현 → completed → SendMessage(Frontend, "API 스펙")
Frontend: UI 구현 → completed → SendMessage(QA, "검증 가능")
QA: 통합 테스트 → completed → SendMessage(Lead, "전체 PASS")

Lead → 3개 PR을 3명에게 분배
Lead → 소환 (techlead, backend, qa)

TechLead: PR #101 아키텍처 리뷰 → completed
Backend: PR #102 API 로직 리뷰 → completed
QA: PR #103 테스트 코드 리뷰 → completed

→ 3개 PR이 동시에 리뷰됨 (시간 1/3 절약)

Lead → 문제 영역별 조사 태스크 생성
Lead → 소환 (rag, etl, db, infra)

RAG: 임베딩/검색 로직 분석
ETL: 데이터 파이프라인 품질 확인
DB: 인덱스/쿼리 성능 분석
Infra: 컨테이너 리소스 확인

→ 각자 조사 후 Lead에게 보고
→ Lead가 종합하여 수정 방향 결정

[Lead] 작업을 분할합니다...
[Backend] idle → 메시지 수신, 깨어남
[Backend] API 엔드포인트 구현 시작
[Frontend] idle → 메시지 수신, 깨어남
[Frontend] UI 컴포넌트 구현 시작
[Backend] ✅ 구현 완료
[Frontend] ✅ 구현 완료
[Lead] 모든 작업이 완료되었습니다.

┌─────────────────────┬─────────────────────┐
│ [Lead]              │ [Backend]            │
│ 작업 조율 중...      │ API 구현 중...        │
│                     │                      │
├─────────────────────┼─────────────────────┤
│ [Frontend]          │ [QA]                 │
│ UI 구현 중...        │ 테스트 작성 중...      │
│                     │                      │
└─────────────────────┴─────────────────────┘

✅ 올바른 할당:
  RAG      → knowledge_service/src/app/services/graph_search.py
  Backend  → gateway/src/main/resources/application.yml
  Frontend → frontend/src/components/GraphPanel.tsx
  QA       → knowledge_service/src/tests/e2e/test_graph_search.py

❌ 잘못된 할당:
  RAG      → knowledge_service/src/app/services/graph_search.py
  Backend  → knowledge_service/src/app/services/graph_search.py  ← 충돌!

Lead가 태스크 설계 시 의존성을 명확히 설정:

TaskCreate(#1 "DB 스키마 설계")
TaskCreate(#2 "API 구현", blockedBy: [#1])
TaskCreate(#3 "UI 구현", blockedBy: [#2])
TaskCreate(#4 "E2E 테스트", blockedBy: [#2, #3])

→ blockedBy가 resolved되면 자동으로 작업 가능
→ 팀원은 TaskList에서 blockedBy 없는 태스크만 claim

Agent Teams 비용 = 팀원 수 × 각 인스턴스 토큰 소비

예시:
  Lead (1명)     : 기본 비용
  Teammates (4명) : 4 × 인스턴스 비용
  메시지 교환     : 추가 토큰 소비
  ─────────────────────────
  총 비용         : 약 5~6배 (단일 에이전트 대비)

# Step 1: 팀 생성 (Lead가 한 번만 실행)
TeamCreate("my-team", description="작업 설명")

# Step 2: 태스크 생성
TaskCreate("API 구현", description="...")
TaskCreate("UI 구현", description="...", blockedBy: [#1])

# Step 3: 팀원 소환 (필요한 만큼만)
Task(subagent_type="backend-developer", team_name="my-team", name="backend", ...)
Task(subagent_type="frontend-developer", team_name="my-team", name="frontend", ...)

# Step 4: 팀원이 자율적으로 작업 수행
# → TaskList 확인 → claim → 수행 → completed → 다음 태스크

# Step 5: 종료
SendMessage(type="shutdown_request", recipient="backend")
SendMessage(type="shutdown_request", recipient="frontend")
TeamDelete()

# 예시
TeamCreate("hrkp-sprint-09")

# 1) PM 소환 (항상 첫 번째)
Task(subagent_type="project-manager", team_name="hrkp-sprint-09", name="pm",
     prompt="PM입니다. 다음 작업을 분석하고 팀을 조율하세요: {사용자 요청}")

# 2) PM이 팀 구성을 결정하면, 클로드(Main)가 팀원 소환
Task(subagent_type="infra-engineer", team_name="hrkp-sprint-09", name="infra", ...)
Task(subagent_type="qa-engineer", team_name="hrkp-sprint-09", name="qa", ...)

# 예시 (PM이 실행)
TaskCreate(subject="Backend 컨테이너 배포", description="...", activeForm="배포 중")
TaskCreate(subject="E2E 테스트", description="...", activeForm="E2E 테스트 중")
TaskUpdate(taskId="2", addBlockedBy=["1"])  # 배포 완료 후 테스트

# PM이 클로드(Main)에게 소환 요청 (PM은 Task tool 접근 불가)
SendMessage(recipient="team-lead", content="Infra, QA 에이전트 소환을 요청합니다")

Phase 1 (클로드 Main):
  [ ] TeamCreate 실행
  [ ] PM 소환 (항상 첫 번째)
  [ ] 사용자 요청을 PM에게 위임
  [ ] PM 요청에 따라 팀원 소환
  [ ] Slack 시작 알림 (MCP)

Phase 2 (PM):
  [ ] 작업 분해 완료 (3~10분 단위)
  [ ] TaskCreate + 의존성 설정 완료
  [ ] 1파일 = 1에이전트 원칙 준수
  [ ] 필요한 팀원 결정 → 클로드에게 소환 요청

Phase 3 (팀원):
  [ ] Slack 시작/완료 알림
  [ ] TaskUpdate (in_progress → completed)
  [ ] PM에게 완료 보고 (SendMessage)

Phase 4 (QA + PM):
  [ ] QA 테스트 완료 (TEST_MODE=docker)
  [ ] 모든 태스크 completed 확인
  [ ] 클로드(Main)에게 결과 보고

Phase 5 (클로드 Main):
  [ ] 팀원 shutdown
  [ ] Slack 완료 알림 (MCP)

"Sprint 09 Day 1: Audit Log 기능 배포 + E2E 테스트 + 지식관리 페이지 현행화 + 프로세스 매뉴얼 작성"

#1 [completed] Backend 컨테이너 배포 (AuditService IP 검증 복원) → Infra
#2 [completed] Audit Log 기능 E2E 테스트 → QA (blockedBy: #1)
#3 [completed] 지식관리 페이지 현행화 및 버그 수정 → Frontend
#4 [completed] Agent Teams 협업 프로세스 매뉴얼 작성 → Documenter