Chapter 5 · Multi-Agent Coordination Patterns

혼자서는 못 하는 일

『Agentic Architectural Patterns for Building Multi-Agent Systems』 5장 — Ali Arsanjani, Juan Pablo Bustos, Thomas Kurian

회사가 전문 인력의 팀에 기대듯, 앞선 AI 해법도 협연하는 전문 에이전트의 팀을 요구한다. 그런데 여럿이 한 환경에서 움직이면 반드시 충돌하고, 자원을 다투고, 서로 어긋난다. 5장은 그 마찰을 다루는 조율 패턴 열셋의 도감이다. 그리고 이 도감을 관통하는 축은 하나다. 중앙이 지시하느냐, 아니면 아래에서 저절로 생겨나느냐.

00

A strategic guide · map before the journey

전략 지도 — 여행 전에 지도부터 편다

이 장은 “여행 전에 지도부터” 방식을 택한다. 각 패턴의 기술적 세부로 뛰어들기 전에, 전략적 구현 안내를 먼저 펴 놓는다. 큰 그림을 먼저 보면 각 패턴이 어디에 놓이고 왜 중요한지 맥락 속에서 읽히기 때문이다.

중요한 것은 이것이다. 조율 패턴과 성숙도 모델의 관계는 패턴 하나를 특정 단계에 배정하는 문제가 아니다. 조직이 단일 에이전트 시스템(1–3단계)에서 멀티 에이전트 시스템(4단계)으로 나아가면서, 같은 패턴의 구현 자체가 더 동적이고 복잡하고 분산적으로 변해 간다. 진화다.

LV 6 자기수정 LV 5 메타조율 LV 4 기초 협업 ◀ 중앙이 지시한다 아래에서 생겨난다 ▶ 통제의 소재 · LOCUS OF CONTROL 감독자 구조 에이전트 라우터 도구 라우팅 멀티에이전트 계획 지식 공유 감독 트리 자원 배분 블랙보드 컨트랙트넷 시장 충돌 해소 합의 협상 편대 제어 스웜 구조 붉을수록 중앙집중 · 푸를수록 분산 · 누르면 해당 패턴으로 이동

〈지도〉 조율 패턴 열넷의 배치. 위로 갈수록 성숙하고, 오른쪽으로 갈수록 통제가 흩어진다.

에이전틱 AI 성숙도 여섯 단계

성숙도 단계설명확장성규제 준수핵심 패턴
1 · 기본 에이전틱 시스템단일 에이전트가 명확히 정의된 과업을 반자율적으로 처리한다. 단순한 사전 정의 워크플로와 외부 API 함수 호출을 쓴다.적응은 되나 경직. 워크플로가 비교적 고정이라 혁신 여지가 제한된다.관리가 간단. 과업이 잘 정의돼 있어 정책 위반 위험이 최소다.단일 에이전트 기준선, 정적 함수 호출, 워치독 타임아웃, 사람 호출
2 · 동적 단일 에이전트단일 에이전트가 사전 선정된 여러 도구·API 중 문제에 따라 동적으로 고른다.더 다재다능하고 효율적. 적절한 도구를 골라 더 복잡한 문제를 다룬다.승인된 도구를 미리 선별하므로 관리 가능. 다만 자율성이 커지는 만큼 행동 감시가 필요하다.에이전트 라우터(기본), 동적 도구 선택, 단순 RAG, 단순 재시도
3 · 내성(內省) 패턴ReAct와 Reflexion으로 단계적 추론과 자기 성찰을 한다. 피드백 루프로 자기 행동에서 배우고 스스로 교정한다.피드백과 자기수정 덕에 더 복잡한 과업을 다루고 시간이 갈수록 개선된다.실시간 감시와 시정 기제가 필수. 학습하는 동안에도 정책에 부합해야 한다.ReAct, Reflexion, 지시 충실도 감사, 프롬프트 변이를 동반한 적응적 재시도
4 · 멀티 에이전트 시스템여럿의 전문 에이전트가 협업해 복잡한 과업을 다룬다. 각자 겹치지 않는 기능에 집중하고, 조율로 병렬 처리가 가능해진다.대규모 환경에 이상적. 과업을 여러 에이전트에 분산해 효율적으로 병렬 처리한다.더 복잡. 반자율 에이전트들이 규제에 맞게 협업하는지 확인할 감시 체계가 필요하다.감독자 구조, 멀티 에이전트 계획, 공유 인식 기억, 이벤트 기반 반응성, 도구·에이전트 레지스트리
5 · 메타 에이전트 조율다른 에이전트들을 감독·조율하는 메타 에이전트가 등장한다. 동적 과업 재배정과 실시간 계획 조정이 가능해진다.적응력 향상. 메타 에이전트의 최적화된 과업 분배 덕에 변화하는 환경에서도 확장된다.메타 에이전트가 감독자 역할을 한다. 워크플로를 조정하고 과업을 재분배해 정책 준수를 돕는다.메타 에이전트, 블랙보드 토폴로지, 자원 배분, 컨트랙트넷 시장, 감독 트리
6 · 자기수정 에이전트복잡한 다중 턴 피드백 루프를 쓴다. 에이전트들이 서로의 출력을 비평·교정·정련하기를 반복해 지속적 개선을 이룬다.지속적 개선이 내장돼 매우 높다. 실시간으로 진화하므로 동적 과업에 극히 효율적이다.가장 복잡. 자동화된 준수 점검과 자기수정 행동이 필요하다.합의, 협상, 충돌 해소, 프랙탈 CoT, 공진화 학습, 신뢰 감쇠

〈표 5.1〉 에이전틱 AI 성숙도 모델

Note

이 장에서 말하는 “단계”는 모두 위 표 5.1의 에이전틱 AI 성숙도 모델을 가리킨다.

4단계와 5–6단계는 무엇이 다른가

Level 4 · 기초 조율

위에서 아래로, 예측 가능하게

여럿이 잘 정의된 워크플로에서 성공적으로 협업하는, 기능하고 예측 가능하며 감사 가능한 시스템을 세우는 것이 일차 목표다. 조율은 명시적이고 위에서 아래로 관리된다.

  • 위임과 계획 — 감독자 구조가 가장 흔하다. 중앙 오케스트레이터가 멀티 에이전트 계획으로 과업을 분해해 작업자에게 배정한다. 계획은 대체로 정적이거나 반정적이다.
  • 정보와 자원 — 지식 공유는 공유 DB 같은 단순한 공유 인식 기억으로 구현된다. 기본적인 자원 배분과 충돌 해소는 감독자가 사전 정의된 정책과 우선순위 규칙으로 중앙에서 처리한다.
  • 상호작용 — 에이전트들은 대체로 자기들끼리 협상하지 않는다. 감독자가 워크플로를 지시하고 위계적 권위로 충돌을 해소한다.

Levels 5–6 · 고급 조율과 자기수정

아래에서 위로, 저절로 생겨나게

자율성의 도약이다. 모호함을 감당하고, 예기치 못한 사건에 적응하며, 해법 경로를 미리 알 수 없는 문제를 푸는 것을 목표로 설계된다. 초점은 하향식 명령 구조에서 에이전트 사이의 “사회적” 역량으로 옮겨간다.

  • 진화한 위임 — 회복력을 위해 분산 스웜 구조로 가거나 혼합 모델을 택한다. 계획은 동적이 되어 실시간 적응이 가능해진다.
  • 합의 — 데이터가 충돌할 때 반복 토론으로 공유된 이해에 수렴한다.
  • 협상 — 목표가 경합하는 에이전트들이 직접 타협해 더 유연하고 최적인 결과를 낸다.
  • 특수 조율 — 물리 세계와 상호작용하는 시스템에서는 편대 제어가 필수가 된다.
아키텍처 측면멀티 에이전트 (4단계)고급·자기수정 (5–6단계)
일차 목표기능하고 예측 가능하며 감사 가능한 워크플로 확립모호함 감당, 예기치 못한 사건 적응, 동적 문제 해결
조율 모델하향식·명시적. 중앙 권위가 관리한다.상향식·창발적. 에이전트 상호작용에서 생겨난다.
주 아키텍처감독자 구조 — 중앙 오케스트레이터가 워크플로를 지시스웜 또는 혼합 — 에이전트가 P2P 네트워크나 자기조직 팀으로 작동
계획 방식정적 계획. 감독자가 과업을 분해하고 대체로 고정된 계획을 지시한다.동적 계획. 계획이 적응적이며 실시간으로 수정될 수 있다.
지식 공유단순 공유 메모리. 주로 에이전트 간 상태 전달에 쓴다.풍부한 공유 인식 기억. 집단 지능을 쌓는 데 쓴다.
충돌 해소중앙집중·정책 기반. 감독자가 사전 정의 규칙으로 해소한다.자율·협상. 에이전트가 협상과 합의로 직접 해소한다.

〈표 5.3〉 성숙도 단계별 조율 패턴 매핑

위계를 갖추는 것만으로는 부족하다. 시스템에는 들어온 요청을 분석해 올바른 전문가에게 보내는 구체적 기제가 있어야 한다. 감독자는 “3분기 감사 로그”에 관한 질의가 영업 에이전트가 아니라 규제 준수 에이전트로 가야 한다는 것을 대체 어떻게 아는가. 첫 번째 패턴은 거기서 시작한다.

01

Foundational dispatch

에이전트 라우터 — 조율의 “Hello World”

P01

Agent Router · Intent-based routing

에이전트 라우터 — 의도 기반 라우팅

LV 4중앙집중

맥락

시스템이 저마다 다른 역량을 가진 전문 에이전트 묶음을 갖고 있다. 사용자는 자연어로 상호작용하는데, 그 자연어는 흔히 모호하고 표현이 제각각이며 무관한 잡음을 포함한다.

문제와 힘

구조화되지 않고 변동이 큰 자연어 요청을, 역량을 환각하지 않고 취약한 키워드 매칭에도 기대지 않으면서, 그 일에 가장 적합한 에이전트에 어떻게 정확히 대응시킬 것인가.

  • 모호함 대 정밀함 — 사용자 입력은 막연하고 비구조적인데, 에이전트 실행은 정밀하고 구조화된 명령을 요구한다.
  • 확장성 대 유지보수 — 새 에이전트를 더한다고 중앙 라우팅 로직을 다시 써야 해서는 안 된다.
  • 안전 대 환각 — 처리할 수 없는 에이전트로 요청이 가는 일은 결코 없어야 한다. 가드레일 밖의 일을 시도하는 위험을 피해야 한다.

해법

두 단계로 나눈다. 첫째, 엄격한 스키마를 강제한 LLM으로 의미 기반 의도 추출을 수행해 원시 질의를 표준화된 동작(동사)과 자원(명사)을 담은 “의도 객체”로 옮긴다. 둘째, 그래프 제약 라우팅으로 조회표나 지식 그래프에 질의해, 그 특정 자원에 그 특정 동작을 수행할 역량을 주장하는 에이전트를 찾는다. 그래프에 유효한 경로가 있으면 라우팅하고, 없으면 미지원으로 거부한다.

사례 — 규제 준수 요청 라우팅

"3분기 재무 프로젝트의 최신 보안 감사는 어디에 있나?"

01의도 추출{Action:"Find", Resource:"Document", Params:{"type":"audit","period":"Q3"}}
02그래프 조회 — 역량 그래프에 (Find, Document) 튜플을 질의
03평가 — SalesAgent는 (Find, SalesReport)로 등록 → 불일치. ComplianceAgent는 (Find, Document)로 등록 → 일치
04디스패치 — ComplianceAgent를 인스턴스화하고 매개변수를 넘긴다
구현 예시 · Python
# 1. 시스템의 "어휘"를 정의한다
ActionType   = Literal["find", "analyze", "create"]
ResourceType = Literal["sales_report", "server_log", "document"]

class RoutingIntent(BaseModel):
    action: ActionType
    resource: ResourceType
    parameters: dict

class AgentRouter:
    def __init__(self):
        # 역량 그래프: (동작, 자원) → 에이전트
        self.capability_graph = {
            ("find",    "sales_report"): "SalesAgent",
            ("analyze", "sales_report"): "SalesAgent",
            ("find",    "document"):     "ComplianceAgent",
            ("create",  "server_log"):   "DevOpsAgent"
        }

    def route_request(self, intent: RoutingIntent):
        key = (intent.action, intent.resource)
        target = self.capability_graph.get(key)

        # 안전 점검: 그래프에 연결이 없으면 요청을 차단한다
        if not target:
            return f"Error: No agent can '{intent.action}' a '{intent.resource}'."

        return self.dispatch_to_agent(target, intent.parameters)

장점

  • 결합 해체 — 추출 계층은 에이전트 이름을 몰라도 되고, 에이전트는 자연어를 파싱하지 않아도 된다. 구조화된 “의도 객체”로 소통한다.
  • 확장성 — 새 에이전트를 더하려면 역량을 그래프에 등록하기만 하면 된다. 라우팅 로직은 그대로다.
  • 안전 — 그래프가 화이트리스트 노릇을 한다. 그래프에 명시적으로 정의되지 않은 이상 라우터는 “데이터베이스 삭제” 명령을 물리적으로 보낼 수 없다.

단점

  • 지연 — 의도 추출 단계가 LLM 호출을 요구해, 실제 작업 전에 지연이 붙는다.
  • 스키마 경직성 — 사용자가 사전 정의된 동작·자원 열거형에 맞지 않는 것을 요청하면 추출이 실패하거나 품질이 떨어진다.

구현 지침

성패는 스키마 정의의 품질에 크게 달렸다. 동작과 자원을 정할 때 “골디락스” 수준의 추상화를 노려야 한다. 너무 잘게 쪼개면(FindPDF, FindWordDoc) 라우팅 그래프가 비대해져 유지가 어렵고, 너무 넓으면(DoWork) 에이전트를 구별하는 능력을 잃는다. 대개 정규화된 동작과 자원 10~20개면 충분하다.

의미 기반 의도 추출에는 단순 프롬프트 엔지니어링보다 함수 호출 모드를 강력히 권한다. 엄격한 JSON 출력 구조를 강제해, 자유 텍스트 응답에서 흔한 파싱 오류를 없앤다.

마지막으로 라우팅 계층에 의미 캐시를 두는 것을 고려하라. 기업 환경에서는 비슷한 질문이 반복된다. 사용자 질의를 임베딩해 벡터 DB에서 유사 요청을 확인하면 반복 질의에 대해 LLM 추출 단계를 통째로 건너뛸 수 있어 지연과 비용이 크게 준다.

02

Task delegation frameworks

과업 위임 프레임워크 — 시스템의 “운영체제”

가장 먼저, 그리고 가장 크게 영향을 미치는 결정이 통제 구조다. 사람 조직에 명확한 관리 방식이 필요하듯, 에이전틱 시스템에도 일을 나누는 정의된 모델이 필요하다. 이것은 개별 상호작용의 패턴을 넘어 시스템의 운영체제로 기능하며, 통제와 통신의 흐름을 빚는다.

위계적 프레임워크는 권한의 선이 분명해 감시가 쉽다. 감사 가능성과 예측 가능성이 관건인 기업 응용에서 흔히 택한다. 반대로 분산 프레임워크는 유연성과 회복력이 크고, 해법 경로를 미리 정할 수 없는 창의적이거나 매우 동적인 영역에 맞는다.

P02

Supervisor Architecture · Centralized orchestration

감독자 구조 — 중앙집중 오케스트레이션

LV 4최중앙집중

맥락

복잡한 과업이 여러 단계의 실행을 요구하며, 흔히 순차적이거나 조건부다. 시스템은 명확한 지휘 계통과 책임 아래 절차가 올바로 지켜지도록 해야 한다.

문제와 힘

여러 단계와 전문 역량을 요구하는 복잡한 과업을, 사람이 계속 개입하지 않으면서 어떻게 신뢰성 있고 예측 가능하게 실행할 것인가.

  • 예측 가능성 대 유연성 — 구조화된 워크플로는 예측 가능하고 관리하기 쉽지만, 예기치 못한 상황에 적응할 유연성이 부족할 수 있다.
  • 중앙집중 대 병목 — 통제를 중앙화하면 거버넌스와 디버깅이 쉬워지지만 단일 실패 지점이자 성능 병목이 생긴다.
  • 전문화 대 조율 부담 — 전문 에이전트는 개별 과업의 효율을 높이지만 인계와 전체 조율의 복잡도를 키운다.

해법

단일 에이전트를 임명해 모든 조율을 맡긴다. 오케스트레이터의 주 기능은 사용자 요청을 해석하고, 계획을 수립하고(사전 프로그래밍이든 동적 생성이든), 필요에 따라 작업자 에이전트를 부르는 것이다. 각 작업자의 출력을 받아 다음 단계를 결정하며, 전체 목표가 통제되고 의도된 방식으로 달성되도록 보장한다.

사례 — 중앙집중 대출 처리

01오케스트레이션 — “이 대출 신청을 처리하라”는 상위 과업을 받는다
02위임 — 신청서를 DocumentValidationAgent에 보낸다
03실행 — 검증 에이전트가 과업을 수행하고 결과를 오케스트레이터에 돌려준다
04조건부 위임 — 결과에 따라(서류 유효) 다음 단계를 CreditCheckAgent에 위임한다
05완료RiskAssessmentAgent의 최종 위험 점수를 받아 요약을 조립하고 최종 결정을 내린다
구현 예시 · Python
class LoanOrchestratorAgent:
    def __init__(self):
        self.doc_validator  = DocumentValidationAgent()
        self.credit_checker = CreditCheckAgent()
        self.risk_assessor  = RiskAssessmentAgent()

    def handle_loan_application(self, application_data):
        # 1단계: 서류 검증 위임
        validation_result = self.doc_validator.validate(application_data)
        if validation_result != "valid":
            return "Application Rejected: Invalid Documents"

        # 2단계: 신용 조회 위임
        credit_report = self.credit_checker.check(application_data.applicant_id)
        if credit_report.score < 600:
            return "Application Rejected: Low Credit Score"

        # 3단계: 위험 평가 위임
        risk_assessment = self.risk_assessor.assess(application_data, credit_report)

        # 4단계: 최종 결과 조립과 결정
        return self.make_final_decision(risk_assessment)

장점

  • 예측 가능성 — 명확하고 예측 가능한 흐름이라 감시·디버깅·감사가 간단하다.
  • 거버넌스 — 중앙 통제가 업무 규칙과 규제 준수의 집행을 단순하게 만든다.

단점

  • 확장성 — 단일 오케스트레이터가 규모가 커질수록 성능 병목이 된다.
  • 단일 실패 지점 — 오케스트레이터가 죽으면 워크플로 전체가 멈춘다.

구현 지침

가장 중요한 설계 원칙은 “신(神) 에이전트”를 만들지 않도록 관심사를 엄격히 분리하는 것이다. 오케스트레이터는 오직 조율 — 과업 라우팅, 상태 추적, 결과에 근거한 결정 — 만 책임져야지 도메인 로직을 직접 실행해서는 안 된다. 실질적 작업은 모두 전문 작업자 에이전트에 캡슐화한다.

이 중앙집중 모델의 신뢰성은 견고한 상태 관리에 달렸다. 감독자가 단일 실패 지점이므로 워크플로의 매 단계 후 상태를 영속화해야 한다. 흔히 체크포인팅이라 부른다. LangGraph 같은 프레임워크가 바로 이 목적으로 설계돼 그래프 상태를 DB에 영속화한다. 그래야 오케스트레이터나 인프라가 죽어도 데이터 손실 없이 정확히 멈춘 자리에서 재개할 수 있다.

감독자와 작업자의 통신은 결정론적이어야 한다. 인계에 자유 형식 자연어를 쓰는 것은 불안정을 자초하는 일이다. Pydantic이나 JSON 모드로 엄격한 출력 스키마를 강제해 오케스트레이터가 프로그램적으로 파싱할 수 있는 구조화 데이터를 받게 하라. 나아가 감독자는 장애의 중앙 처리자여야 한다. 작업자가 실패하거나 멈추면 재시도하거나, 백업 에이전트로 돌리거나, 우아하게 실패시키는 로직을 감독자가 갖고 있어야 한다.

P03

Swarm Architecture · Emergent decentralized coordination

스웜 구조 — 창발적 분산 조율

LV 6최분산

맥락

복잡한 과업이 동적이고 비구조적이거나, 시스템이 변화에 매우 회복력 있고 적응적이어야 한다. 단일 실패 지점을 용납할 수 없고, 문제 해결이 경직된 순차 흐름보다 병렬적·자율적 행동에 더 잘 맞는다.

문제와 힘

중앙 오케스트레이터 없이 자율 에이전트 무리가 공동 목표를 어떻게 효과적으로 달성할 것인가. 분산적이고 회복력 있는 방식으로 과업 발견·인계·완료의 기제가 필요하다.

  • 자율성 대 조율 — 자율성을 극대화하면 회복력과 적응성이 오르지만, 명시적 조율이 없으면 중복 작업이나 목표 어긋남이 생긴다.
  • 확장성 대 부담 — 분산 네트워크는 병목 없이 수평 확장되지만, 에이전트 간 잡담을 관리할 효율적 통신 프로토콜이 필요하다.
  • 창발 대 예측 가능성 — 자기조직은 창의적이고 적응적인 해법을 낳지만, 최종 결과가 덜 예측 가능하고 디버깅이 어려울 수 있다.

해법

공유 통신 게시판 또는 과업 보드에 의존한다. 과업이 게시되면 준비된 에이전트가 보드에서 그것을 당겨 온다. 자기 몫을 마치면 보드의 과업 상태를 갱신해 다음 전문 에이전트가 이어받게 한다. 비동기 병렬 처리가 가능해지고 단일 통제점에 대한 의존이 사라진다.

사례 — 분산 콘텐츠 제작

01과업 방송 — “태양광에 관한 블로그 글을 써라”가 공유 과업 보드에 게시된다
02자기 선택ResearchAgent가 보드를 폴링해 상태 new를 확인하고 스스로 집는다
03실행과 갱신 — 사실을 모아 과업에 기록하고 상태를 researched로 바꾼다
04인계DraftingAgent가 그 상태를 보고 당겨 와 초안을 쓰고 drafted로 바꾼다
05완료EditorAgent가 최종 교정을 하고 complete로 표시한다
구현 예시 · Python
class ResearchAgent:
    def check_for_tasks(self, shared_task_board):
        task = shared_task_board.get("task_id_123")
        if task.status == "new":
            task.data["research"] = self.gather_facts(task.topic)
            task.status = "researched"   # 다음 에이전트를 위한 상태 갱신

class DraftingAgent:
    def check_for_tasks(self, shared_task_board):
        task = shared_task_board.get("task_id_123")
        if task.status == "researched":
            task.data["draft_content"] = self.write_draft(task.data["research"])
            task.status = "drafted"

class EditorAgent:
    def check_for_tasks(self, shared_task_board):
        task = shared_task_board.get("task_id_123")
        if task.status == "drafted":
            task.data["final_text"] = self.proofread(task.data["draft_content"])
            task.status = "complete"

장점

  • 회복력 — 중앙 통제자가 없으므로 단일 실패 지점이 없다. 일부 에이전트가 죽어도 계속 작동한다.
  • 확장성 — P2P 성격 덕에 에이전트를 더하기만 하면 수평 확장된다.

단점

  • 디버깅 난이도 — 창발적이고 비선형인 과업 흐름은 행동을 예측하고 디버깅하기 어렵게 만든다.
  • 거버넌스 — 중앙 권위 없이 업무 규칙을 강제하거나 규제 준수를 보장하기가 까다롭다.

구현 지침

멀티 에이전트 시스템을 설계할 때 중앙집중에서 출발하는 것이 좋은 시작점이다. 대부분의 기업 응용에서 감독자 구조가 만들기·디버깅·통치하기 쉽고, 책임의 선이 분명하며 감시의 중심점을 제공한다.

다만 시간이 가면서 분산화가 이로운 응용도 있다. 스웜은 장애에 더 회복력 있고 조건 변화에 적응적이라 자율성이 필수인 동적 환경에 자연스럽게 맞는다. 실무에서 복잡한 시스템 다수는 혼합 모델을 택한다. 최상위 오케스트레이터가 전체 업무 프로세스를 관리하되, 큰 하위 목표는 자기조직하는 “스웜”이나 “크루”에 위임해 실행의 세부는 자기들끼리 처리하게 한다. 중앙 통제의 명료함과 분산 의사결정의 적응성을 함께 얻는 균형점이다.

특징감독자 구조 (중앙집중)스웜 구조 (분산)
통제 흐름위계적. 단일 오케스트레이터가 작업자에게 과업을 위임한다.P2P. 에이전트가 스스로 고르거나 서로에게 과업을 넘긴다.
조율명시적·하향식. 감독자가 워크플로를 관리한다.창발적·상향식. 국소 상호작용에서 조율이 생겨난다.
모듈성높음. 감독자 아래에 전문 에이전트를 쉽게 더하거나 교체한다.높음. 에이전트가 자율적이라 스웜에 더하거나 뺄 수 있다.
핵심 이점예측 가능성과 명확한 감시. 디버깅과 통치가 쉽다.회복력과 적응성. 단일 실패 지점이 없다.
핵심 약점감독자가 성능 병목이나 단일 실패 지점이 될 수 있다.통치와 디버깅이 어렵다. 전체 행동이 덜 예측 가능하다.
적합한 곳구조화된 업무 프로세스, 단계가 분명한 워크플로(예: 대출 처리)창의적 과업, 동적 문제 해결, 높은 회복력이 필요한 환경

〈표 5.2〉 과업 위임 구조의 비교

03

Agent composition topologies

구성 토폴로지 — 에이전트와 데이터의 구조적 배열

감독자냐 스웜이냐를 고르는 것이 권위의 흐름을 정한다면, 구성 토폴로지는 에이전트와 데이터의 구조적 배열을 더 구체적으로 규정한다. 지식 수렴, 시장 기반 과업 할당, 내결함성이라는 각각의 과제를 겨냥한 셋을 본다.

P04

Blackboard Knowledge Hub

블랙보드 지식 허브 — 칠판에 함께 쓴다

LV 5혼합

맥락

어느 에이전트도 문제 전체를 풀 지식을 갖지 못한, 규정이 불분명하거나 복잡한 문제를 다룬다. 해법은 여러 “전문가”의 기여가 점진적으로 쌓여야 나오고, 기여의 순서를 미리 완전히 정할 수 없다.

문제와 힘

규모가 커지면 감당할 수 없게 되는 직접적이고 강결합된 통신 채널 없이, 독립적인 에이전트 여럿이 발전하는 해법에 어떻게 협업할 것인가.

  • 공유된 이해 대 경쟁 조건 — 문제 상태에 대한 통일된 관점이 필요하지만 동시 갱신은 충돌을 낳는다.
  • 개방성 대 품질 통제 — 다양한 전문가의 기여에 열려 있어야 하지만 저품질이거나 환각인 데이터는 걸러야 한다.
  • 전역 일관성 대 에이전트 자율성 — 에이전트는 독립적으로 행동해야 하지만 최종 해법은 전역적으로 일관돼야 한다.

해법

타입이 있고 버전이 매겨진 사실과 가설을 담는 중앙 저장소, 곧 블랙보드를 둔다. 지식원(에이전트)들은 서로 직접 통신하지 않고 블랙보드에 갱신을 게시한다. 컨트롤러가 절차 국면(게시 → 평가 → 통합)을 중재해 기여가 검증되고 해법이 논리적으로 수렴하도록 한다.

사례 — 협업 의료 진단

01게시SymptomAnalysisAgent가 “환자에게 발열과 발진이 있다”를 블랙보드에 올린다
02촉발 — “발진”을 본 DermatologyAgent가 발동해 이미지를 분석하고 “발진은 잠재적 바이러스 감염을 시사(신뢰도 0.8)”를 올린다
03정련VirologyAgent가 이 가설을 읽고 혈액 검사 결과를 요청한다
04수렴 — 컨트롤러가 집합적 사실을 평가하다가 DiagnosisAgent가 충분한 신뢰도로 최종 진단을 종합한다
구현 예시 · Python
class Blackboard:
    def __init__(self):
        self.facts = []

    def post_hypothesis(self, agent_id, hypothesis, confidence):
        entry = {"agent": agent_id, "data": hypothesis,
                 "conf": confidence, "timestamp": now()}
        self.facts.append(entry)
        return entry

class Controller:
    def run_cycle(self, problem_state):
        # 1. 선택: 현재 상태에 기여할 수 있는 에이전트를 정한다
        eligible_agents = self.select_knowledge_sources(problem_state)

        # 2. 실행: 에이전트가 블랙보드에 쓴다
        for agent in eligible_agents:
            hypothesis = agent.generate_hypothesis(problem_state)
            self.blackboard.post_hypothesis(agent.id, hypothesis)

        # 3. 평가: 검증기가 수렴 또는 충돌을 확인한다
        if self.validator.check_convergence(self.blackboard.facts):
            return self.validator.synthesize_solution()

장점

  • 유연성 — 나아갈 길이 불분명하고 반복적 기여가 필요한 잘못 정의된 문제에 탁월하다.
  • 감사 가능성 — 추가만 가능한 로그가 해법이 어떻게 진화했는지 명확한 이력을 남긴다. 시스템의 “사고 사슬”을 설명하는 데 결정적이다.

단점

  • 지연 — 중앙 기록과 평가 단계가 지연을 만들어 직접 메시지 전달보다 느리다.
  • 병목 — 블랙보드가 제대로 샤딩·색인되지 않으면 컨트롤러가 처리량 병목이 된다.

구현 지침

“약한” 전문가가 많거나 추적 가능한 수렴이 절실할 때 가장 잘 맞는다. 반대로 저지연의 단순 도구 과업에는 피해야 한다. 블랙보드 상태 관리 부담이 이익을 넘어선다. 위생을 위해 정리 전략이나 망각 기제를 구현해 낡거나 무효화된 사실을 잘라내야 한다. 그러지 않으면 블랙보드가 소음투성이 낙서장이 되어 에이전트 성능을 떨어뜨린다.

P05

Contract-Net Marketplace · Mediator + Bids

컨트랙트넷 시장 — 입찰로 정한다

LV 5시장 기반

맥락

다양한 에이전트 풀을 가진 분산 환경이다. 역량은 겹치지만 가용성·비용·성능 특성이 동적으로 변한다. 실시간 부하나 과업의 미묘한 차이를 반영할 수 없으므로 정적 라우팅 로직은 취약하고 비효율적이다.

문제와 힘

최적 선택이 가용성·비용·신뢰도처럼 런타임에야 알 수 있는 동적 요인에 달렸을 때, 가장 적합한 에이전트에게 어떻게 과업을 배정할 것인가.

  • 전문화 대 라우팅 부담 — 고도로 전문화된 에이전트를 원하지만 그들에게 수동으로 라우팅하는 일은 복잡하다.
  • 경쟁 입찰 대 조율 비용 — 입찰은 최적 에이전트가 일을 맡게 하지만 경매 과정이 시간과 연산을 잡아먹는다.
  • 탐색 대 SLA — 최선의 선택지를 탐색하고 싶지만 실행 기한을 놓쳐서는 안 된다.

해법

시장 기반 협상 기제인 컨트랙트넷 프로토콜을 구현한다. 의뢰자(관리자)가 잠재적 작업자들에게 과업 공고를 방송한다. 입찰자는 공고를 평가해 역량·비용·예상 도착시간(ETA)·신뢰도 점수를 담은 정식 입찰서로 응답한다. 의뢰자는 낙찰자로서 효용 점수가 가장 높은 에이전트에게 과업을 배정한다.

사례 — 클라우드 제공자 에이전트 선정

01공고TrainingSolicitor가 방송한다. “과업: 모델 X 학습. 제약: 최대 비용 $100.”
02입찰AWS_Agent $90, ETA 2시간 · Azure_Agent $85, ETA 2.5시간 · OnPrem_Agent $10, ETA 12시간
03낙찰 — 의뢰자가 시간과 돈을 저울질해 균형이 가장 좋은 AWS_Agent에 계약을 준다
구현 예시 · Python
class Solicitor:
    def request_task_fulfillment(self, task):
        # 1. 가용 구독자 전체에 과업을 공고한다
        bids = self.broadcast_announcement(task)

        # 2. 효용 함수(신뢰도 대 비용)로 입찰을 평가한다
        best_bid = self.evaluate_bids(bids)

        if best_bid:
            # 3. 계약을 낙찰한다
            return best_bid.agent.execute_contract(task)
        else:
            raise NoBidsException()

class BidderAgent:
    def receive_announcement(self, task):
        if not self.can_handle(task):
            return None   # 거절

        cost       = self.estimate_compute_cost(task)
        confidence = self.assess_capability(task)
        return Bid(agent=self, cost=cost, confidence=confidence)

장점

  • 적응적 선택 — 코드 변경 없이 에이전트 가용성과 역량 변화에 동적으로 적응한다.
  • 높은 활용도 — 요청자와 제공자를 분리해, 그 순간 가장 적합한 에이전트로 일이 흐르게 한다.

단점

  • 경매 지연 — 협상 과정이 작업 시작 전에 부담을 얹는다.
  • 기만의 위험 — 정직한 입찰에 대한 유인이 없으면 에이전트가 신뢰도를 과장해 과업을 따낼 수 있다.

구현 지침

도구가 많고 변동이 크거나 비용·속도 같은 동적 요인을 최적화할 때 쓴다. 반대로 정적 라우팅이 더 단순하고 빠른 고정적·예측 가능한 워크플로에는 피한다. 무한 대기를 막으려면 의뢰자가 입찰 접수 기한을 엄격히 강제해야 한다. 아울러 계약을 따내고도 품질을 내지 못하는 에이전트에게 불이익을 주는 평판 점수 도입을 고려하라.

P06

Supervision Tree with Guarded Capabilities

감독 트리 — 터지게 두되, 번지지 않게

LV 5위계

맥락

Erlang과 Akka로 유명한 액터 모델에서 온 패턴이다. 생성된 코드 실행, 웹 스크래핑, 불안정한 외부 API 호출처럼 자율적이고 잠재적으로 위험한 도구 호출을 여럿이 수행하는 시스템에 필수다.

문제와 힘

자율 에이전트의 실패를 애플리케이션 전체를 무너뜨리지 않고 어떻게 봉쇄하면서도, 작동할 충분한 자유는 남길 것인가.

  • 안전 대 속도 — 에이전트가 자율적으로 빠르게 움직이길 원하지만, 하위 에이전트의 처리되지 않은 예외가 위로 전파돼 메인 오케스트레이터를 죽일 수 있다.
  • 격리 대 협업 — 데이터를 공유해야 협업하지만, 메모리를 직접 공유하면 한 에이전트의 오염된 상태가 다른 에이전트를 감염시킨다.
  • 개발 민첩성 대 정책 집행 — 새 역량을 빨리 더해야 하지만, 모든 에이전트에 전체 시스템 접근을 주는 것은 최소 권한 원칙을 위반한다.

해법

에이전트를 위계적으로 조직한 감독 트리를 구현한다. 감독자는 오직 자식(작업자)의 생애주기 관리만 책임지는 전문 에이전트다. 자식이 죽거나 정책을 위반하면 감독자가 감지해 복구 전략(예: 자식 재시작)을 적용한다. 역량은 서브트리별로 부여되어, “연구” 가지가 “결제” 도구에 접근할 수 없게 한다.

사례 — 회복력 있는 웹 스크레이퍼

01생성 — 루트 감독자가 ResearchSupervisor를 낳고, 그것이 ScraperAgent 셋을 낳는다
02실패 — 한 스크레이퍼가 캡차에 막혀 치명적 오류를 던지거나 루프에 갇힌다
03감지ResearchSupervisor가 크래시 신호를 잡는다
04복구 — “하나에 하나(one-for-one)” 전략에 따라 실패한 것만 깨끗한 상태로 재시작한다. 나머지는 계속 돌고, 실패는 봉쇄된다
구현 예시 · Python
class SupervisorAgent:
    def __init__(self, strategy="ONE_FOR_ONE"):
        self.children = []
        self.strategy = strategy

    def spawn_child(self, agent_cls, tools):
        # 이 자식에게만 특정 도구를 넘겨 역량을 격리한다
        child = agent_cls(allowed_tools=tools)
        self.children.append(child)
        return child

    def monitor_loop(self):
        for child in self.children:
            if child.status in ("CRASHED", "POLICY_VIOLATION"):
                self.handle_failure(child)

    def handle_failure(self, failed_agent):
        log_incident(failed_agent.id, failed_agent.error)
        if self.strategy == "ONE_FOR_ONE":
            failed_agent.restart()          # 깨끗한 상태로 재시작
        elif self.strategy == "ESCALATE":
            # 감당 못 하면 스스로 죽어 트리 위로 신호를 올린다
            raise SupervisorFailureException(failed_agent)

장점

  • 높은 회복력 — 자동 오류 복구로 사람 개입 없이 자가 치유한다.
  • 폭발 반경 통제 — 위험한 가지(예: 웹 스크레이퍼)의 크래시가 안전한 가지나 루트 오케스트레이터에 영향을 주지 않는다.

단점

  • 복잡도 — 아키텍처 안무가 늘어난다. 개발자가 트리와 생애주기 관리로 사고해야 한다.
  • 통신 부담 — 트리를 가로지르는 통신에 명확한 관문(메일박스)이 필요하다. 형제의 데이터를 그냥 “집어올” 수 없다.

구현 지침

웹 브라우징이나 코드 실행처럼 불안정한 도구를 쓰는 운영 시스템에 결정적이다. 설정 부담이 실행 시간을 압도하는 단순 일회성 유틸리티에는 깊은 감독 트리를 피하라. 복구 전략을 정할 때는 반드시 백오프 로직을 넣어야 한다. 자식이 1초에 다섯 번 죽으면 재시작을 멈춰 자원을 태우는 크래시 루프를 막는다. 그리고 자식이 감독자를 우회해 루트와 직접 통신하는 일은 항상 금지해야 한다.

04

Planning · Knowledge · Tools

계획하고, 나누고, 손을 뻗는다

토폴로지는 시스템에 형태를 준다. 그러나 형태만으로는 문제가 풀리지 않는다. 조직된 에이전트들에게는 복잡한 목표를 다룰 과정이 필요하다. 계획을 세우고, 알아낸 것을 나누고, 바깥 세계에 손을 뻗는 세 패턴을 본다.

P07

Multi-Agent Planning

멀티 에이전트 계획 — 집단을 움직이는 인지 엔진

LV 4중앙집중

맥락

단일 에이전트가 혼자 풀기에 너무 크거나 다면적인 문제가 주어졌다. 전체 목표는 분명하지만 단계의 순서와 분업이 정해져 있지 않다.

문제와 힘

자율 에이전트 무리가 공동 목표를 위한 통일된 계획을 어떻게 함께 만들고 실행할 것인가. 공유 계획이 없으면 중복 작업, 잘못된 순서, 결과 결합 실패로 비효율이나 완전한 실패에 이른다.

  • 분해 대 응집 — 큰 목표를 작은 과업으로 쪼개야 하지만, 하위 과업들이 응집을 유지하며 전체 목표에 기여해야 한다.
  • 전문화 대 조율 부담 — 전문 에이전트는 효율을 높이지만 인계 관리의 복잡도를 키운다.
  • 정적 대 동적 계획 — 사전 정의된 계획은 예측 가능하지만 새 정보나 예기치 못한 난관에 적응할 유연성이 없다.

해법

상위 목표를 다룰 만한 하위 과업의 그래프나 순서로 분해하고 가장 적합한 에이전트에게 배정하는 기제를 세운다. 흔히 협업적 과업 분해라 부르며, 중앙집중 프레임워크에서는 대개 오케스트레이터가 맡는다. 계획 자체가 집단의 행동을 이끄는 공유 산출물이 된다.

사례 — 시장 분석 보고서 생성

“제품 X에 대한 포괄적 시장 분석 보고서를 생성하라”가 하위 과업으로 분해된다.

01gather_sales_dataDataRetrieverAgent
02analyze_competitor_chatterSocialMediaMonitoringAgent
03summarize_analyst_reportsFinancialDocsAgent
04synthesize_findings_and_draft_reportReportWriterAgent

앞의 셋은 병렬로, 마지막은 그 결과에 의존해 순차로 실행된다. 의존성은 오케스트레이터가 관리하거나 에이전트 간 직접 통신으로 관리한다.

구현 예시 · Python
class MarketAnalysisOrchestrator:
    def generate_report(self, product_name):
        # 1. 상위 목표를 계획으로 분해한다
        plan = {
            "task1": {"agent": self.data_retriever, "input": product_name},
            "task2": {"agent": self.social_media,  "input": product_name},
            "task3": {"agent": self.financial_docs, "input": product_name}
        }

        # 2. 독립적인 과업을 병렬로 실행한다
        with concurrent.futures.ThreadPoolExecutor() as executor:
            future_to_task = {
                executor.submit(plan[k]["agent"].run, plan[k]["input"]): k
                for k in plan
            }
            results = {}
            for future in concurrent.futures.as_completed(future_to_task):
                task_name = future_to_task[future]
                try:
                    results[task_name] = future.result()
                except Exception as exc:
                    print(f'{task_name} generated an exception: {exc}')

        # 3. 의존 과업을 실행한다
        return self.report_writer.run(
            results.get("task1"), results.get("task2"), results.get("task3")
        )

장점

  • 효율 — 전문화와 병렬 실행을 활용해 복잡한 문제를 푼다.
  • 전문성 활용 — 전문 에이전트에 배정함으로써 범용 에이전트 하나보다 높은 품질을 낸다.

단점

  • 조율 부담 — 계획 과정 자체가 자원을 쓰며, 효율적으로 설계되지 않으면 병목이 된다.
  • 경직의 위험 — 정적 계획은 환경이 바뀌거나 하위 과업이 실패하면 무너진다.

구현 지침

경직과 조율 부담을 완화하려면 계획이 정적이 아니라 유연해야 한다. 새 정보나 실패한 하위 과업에 반응해 계획을 조정할 수 있어야 한다. 하위 과업 사이의 의존성을 명확히 정의하는 것이 매끄러운 인계와 실행 오류 방지에 필수다.

P08

Knowledge Sharing · Shared Epistemic Memory

지식 공유 — 하나가 배우면 전체가 안다

LV 4–6혼합

맥락

개별 에이전트는 경험을 통해 값진 정보를 얻거나 새 기술을 익힌다. 어떤 에이전트는 특정 DB를 가장 효율적으로 질의하는 법을 배우고, 다른 에이전트는 새로운 유형의 고객 불만을 식별하는 법을 배운다. 공유 기제가 없으면 이 지식은 개별 에이전트 안에 갇힌다.

문제와 힘

한 에이전트가 얻은 값진 지식이나 경험을 다른 에이전트들과 어떻게 나누어 집단 지능을 높일 것인가. 공유 기제가 없으면 각자 모든 것을 독립적으로 배워야 하고, 그 결과 시스템은 부분의 합보다 못한 것이 된다.

  • 고립된 지식 대 집단 지능 — 지식을 각 에이전트에 두는 편이 쉽지만, 그러면 시스템 전체가 배우고 개선될 수 없다.
  • 기록 용이성 대 검색 노력 — 새 지식을 쉽게 쓸 수 있어야 하지만, 저장소는 다른 에이전트가 효율적·정확하게 검색할 수 있도록 구조화돼야 한다.
  • 전파 대 무결성 — 지식을 널리 나누면 문제 해결이 빨라지지만, 틀렸거나 낡은 정보를 퍼뜨릴 위험이 따른다.

해법

모든 에이전트가 읽고 쓸 수 있는 전역·영속 데이터 저장소, 곧 공유 인식 기억(Shared Epistemic Memory)을 구현한다. 단순 지식 그래프, 벡터 DB, 또는 다른 영속 저장소일 수 있다. 단순 메시지 전달을 넘어 중앙화된 지식 풀을 만들어, 시스템 전체가 구성원 개개의 경험에서 배우게 하고 파편화된 이해와 의미 표류를 막는다.

사례 — 공유된 고객 서비스 해법

01Agent_A가 ProWidget X의 Error 503이 기기 캐시를 지우면 일관되게 해결된다는 것을 알아낸다
02Agent_A가 이 성공한 해법을 공유 벡터 DB에 기록한다
03몇 주 뒤 Agent_B가 비슷한 문제를 만나 공유 지식 베이스에 의미 검색을 수행하고, 즉시 그 해법을 찾아 첫 시도에 해결한다
구현 예시 · Python
SHARED_KNOWLEDGE_BASE = VectorDatabase()   # 공유 지식 베이스

class AgentA:
    def handle_issue(self, user_query):
        if "Error 503 on ProWidget X" in user_query:
            solution = "Have the user clear their device's cache."
            # ... 사용자의 문제를 해결한 뒤 ...
            # 성공한 해법을 공유 기억에 기록한다
            SHARED_KNOWLEDGE_BASE.add_entry({
                "problem_description": "Error 503 on ProWidget X",
                "solution_steps": solution
            })

class AgentB:
    def handle_issue(self, user_query):
        # 공유 지식 베이스에서 유사 문제를 검색한다
        relevant = SHARED_KNOWLEDGE_BASE.semantic_search(user_query)
        if relevant:
            return relevant[0].solution_steps   # 다른 에이전트가 찾은 해법을 쓴다

장점

  • 집단 지능 — 가장 큰 이익이다. 모든 에이전트의 집단 경험에서 계속 배우므로 시스템이 부분의 합보다 유능해진다.
  • 효율 — 매번 처음부터 시작하는 대신 기존 지식을 활용해 반복되는 문제를 더 빨리 푼다.

단점

  • 데이터 무결성 — 틀렸거나 악의적인 정보를 전파할 위험이 있다.
  • 거버넌스 부담 — 정확성과 신뢰성을 유지하려면 지식 베이스를 관리·검증·정리하는 체계가 필요하다.

구현 지침

지식 표현에서 출발해야 한다. 구체적이고 객관적인 사실에는 JSON 같은 구조화 형식을, 더 미묘하고 경험 기반인 지식에는 벡터 DB 안의 비정형 텍스트를 쓴다.

저장을 넘어 출처(provenance) 유지가 결정적이다. 공유 지식의 출처를 추적해야 신뢰도를 평가하고, 잘못된 정보가 퍼졌을 때 효과적으로 디버깅할 수 있다.

끝으로 신뢰와 검증 기제를 넣어야 한다. 에이전트가 동료의 기여를 평가하거나 검증하게 하거나, 전담 거버넌스 에이전트가 주기적으로 지식 베이스를 검토하고 정리하게 하는 방법이 있다.

P09

Tool Routing in Multi-Agent Contexts

도구 라우팅 — 선택지를 줄여 정확도를 올린다

LV 4중앙집중

맥락

멀티 에이전트 시스템이 행동을 수행할 다양한 도구(API·함수·DB)에 접근한다. 특정 역량이 필요한 과업이 오면 어느 에이전트가 어느 도구를 호출할지 시스템이 정해야 한다.

문제와 힘

에이전트와 도구가 많을 때, 주어진 하위 과업에 올바른 도구가 선택되고 가장 적합한 에이전트가 그것을 호출하도록 어떻게 보장할 것인가. 에이전트의 목표와 도구가 어긋나면 성능 저하, 잘못된 결과, 자원 낭비로 이어진다.

  • 정확성 대 유연성 — 경직된 하드코딩 라우팅 맵은 알려진 과업에서 높은 정확도를 내지만 예기치 못한 요청을 다룰 유연성이 없다.
  • 중앙집중 대 병목 — 중앙 라우터는 로직을 단순화하지만 트래픽이 많으면 단일 실패 지점이나 병목이 된다.
  • 도구 전문화 대 도구 발견 — 작고 전용인 도구 집합이 이롭지만, 필요하면 새롭거나 외부인 도구를 발견할 기제가 있어야 한다.

해법

각 에이전트나 중앙 감독자에게 자기와 관련된 도구만 서술한 프롬프트를 주어 초점을 높이고 결정 피로를 줄인다. 모든 에이전트가 모든 도구에 접근하는 대신 역량의 범위를 좁힌다. 오케스트레이터나 전담 라우터 에이전트가 그 일에 가장 맞는 도구 집합을 가진 에이전트에게 과업을 보낸다.

사례 — 지능형 개인 비서

01요청 — “구글 주가가 지금 얼마인가?”
02분류 — 중앙 라우터가 의도를 분석해 financial_query로 분류한다
03라우팅 — 시장 데이터용 API 키와 도구를 쥔 FinancialAgent에 위임한다
04전문 실행FinancialAgent가 자기 get_stock_price 도구로 데이터를 가져온다
05완료 — 결과가 사용자에게 반환된다. WeatherAgentTravelAgent건드려지지 않아 답을 환각하거나 도구를 오용할 일이 없다
구현 예시 · Python
class CentralOrchestrator:
    # 어떤 유형의 과업을 어느 에이전트가 맡는지 정의한다
    AGENT_ROUTING_MAP = {
        "financial_query": "FinancialAgent",
        "weather_query":   "WeatherAgent",
        "database_query":  "DatabaseAgent"
    }

    def handle_request(self, user_request):
        request_type = self.classify_request(user_request)      # LLM 분류
        target = self.AGENT_ROUTING_MAP.get(request_type)

        if target:
            return self.get_agent_instance(target).process(user_request)
        return "Sorry, I don't have an agent capable of handling that request."

class FinancialAgent:
    # 이 에이전트는 오직 금융 도구만 안다
    def process(self, request):
        # self.llm.decide_tool(request, available_tools=[get_stock_price_tool])
        ...

장점

  • 높은 정확도 — 에이전트별 도구 선택지를 제한해 잘못된 호출 가능성을 줄인다.
  • 집중 — 에이전트가 자기 영역에서 고도로 전문화되어 효율과 성능이 오른다.

단점

  • 경직성 — 과업이 예기치 않게 에이전트의 사전 정의 집합 밖 도구를 요구하면 유연하지 못하다.
  • 사전 설계 — 라우팅 맵과 에이전트 역량의 신중한 사전 설계와 유지보수가 필요하다.

구현 지침

도구가 아주 많은 시스템이라면 에이전트가 질의할 수 있는 도구 레지스트리를 만드는 것을 고려하라. 하드코딩된 도구–에이전트 배정보다 동적인 라우팅이 가능해진다. 라우팅 로직 자체를 함수 호출을 쓰는 전담 LLM 라우터 에이전트에 위임하면 올바른 에이전트와 그에 딸린 도구를 고르는 데 더 큰 유연성을 얻는다.

05

Protocols for disagreement

불화를 다루는 네 패턴 — 마찰은 결함이 아니다

분산 시스템에 마찰은 자연스럽다. 문제는 마찰이 아니라 마찰을 다룰 규약이 없는 것이다. 사실이 어긋날 때는 합의가, 목표가 부딪칠 때는 협상이, 자원이 모자랄 때는 자원 배분이, 계획이 정면으로 충돌할 때는 충돌 해소가 필요하다.

P10

Consensus

합의 — 사실이 어긋날 때

LV 6분산

맥락

분산 시스템에서 여러 에이전트가 환경 상태에 대해 서로 다르거나 불완전하거나 심지어 상충하는 정보를 갖는다. 조율된 행동으로 나아가려면 먼저 하나의 공유된 이해에 합의해야 한다.

문제와 힘

잡음 있는 데이터나 사소한 불일치가 있는 상황에서도 자율 에이전트 무리가 특정 값이나 상태에 어떻게 보장된 합의에 이를 것인가.

  • 합의 대 개별 정확성 — 에이전트들이 매우 정확하면서도 상충하는 데이터를 가질 수 있다. 합의 과정은 개별 정밀도의 일부를 잃는 대가로 하나의 값에 타협하도록 강제한다.
  • 수렴 대 시간 — 큰 네트워크에서 합의 도달은 시간이 걸린다. 신뢰할 만한 결과와 시의적절한 결정 사이의 균형이 필요하다.
  • 정직한 행위자 대 악의적 행위자 — 알고리즘은 잡음과 사소한 불일치를 감당하면서도, 고의로 거짓 정보를 제공해 과정을 방해하는 에이전트를 식별하고 격리할 기제를 갖춰야 한다.

해법

흔히 반복 토론을 통해 공통 상태로 수렴하는 프로토콜을 제공한다. 에이전트가 현재 믿음을 방송하고, 다른 이의 믿음을 받고, 사전 정의된 규칙에 따라 자기 믿음을 조정한다. 모든 에이전트의 상태가 허용 오차 안으로 수렴할 때까지 반복한다. 행동에 나서기 전에 공유 상태에 대한 견고하고 검증된 이해를 확보하는 방식이다.

사례 — 금융 예측 토론

011차 예측 — 낙관 에이전트 $110M · 비관 에이전트 $95M · 현실 에이전트 $102M
02반복 토론 — 서로 예측을 공유하고 평균($102.3M)을 계산해 각자 그쪽으로 일부 조정한다
03수렴 — 공유와 조정이 이어지며 최고와 최저의 간격이 매 라운드 좁아져 허용 오차 안에 든다
04행동 — 최종 합의 예측 $103M을 선언하고 투자 전략에 반영한다
구현 예시 · Python
class ConsensusManager:
    def get_consensus_forecast(self, agents, tolerance=1.0, max_rounds=5):
        # 1라운드: 초기 예측 수집
        forecasts = {a.name: a.get_initial_forecast() for a in agents}

        for round_num in range(1, max_rounds + 1):
            # 수렴 확인
            if (max(forecasts.values()) - min(forecasts.values())) <= tolerance:
                print(f"Consensus reached in round {round_num}.")
                return sum(forecasts.values()) / len(forecasts)

            # 공유하고 조정한다
            average = sum(forecasts.values()) / len(forecasts)
            for agent in agents:
                forecasts[agent.name] = agent.adjust_forecast(
                    forecasts[agent.name], average)

        print("Max rounds reached. No consensus.")
        return sum(forecasts.values()) / len(forecasts)   # 평균으로 폴백

class FinancialAgent:
    def adjust_forecast(self, current, average, adjustment_factor=0.5):
        # 평균 쪽으로 일정 비율만큼 조정한다
        return current + (average - current) * adjustment_factor

장점

  • 신뢰성 — 구조화된 토론을 통해 결정의 신뢰성과 견고성이 오른다. 잠재적으로 결함 있는 단일 데이터가 아니라 공유되고 검증된 이해에 근거해 행동한다.
  • 내결함성 — 한 에이전트가 참여하지 못하거나 유효한 응답을 못 내도 전체 과정이 반드시 멈추지는 않는다.

단점

  • 지연 — 여러 라운드의 통신과 연산을 요구해 자연스러운 지연이 생긴다. 즉각적 결정이 필요한 실시간 시스템에는 부적합하다.
  • 복잡도 — 에이전트 장애, 네트워크 분할, 악의적 행위자 같은 경계 사례를 신중히 고려해야 해서 구현이 복잡하다.

구현 지침

첫째, 최대 라운드 수나 수렴 임계값 같은 명확한 종료 조건을 세워 무한 루프를 막아야 한다. 둘째, 수렴 알고리즘이 에이전트가 상태를 조정하는 주 로직이 된다. 단순 산술 평균부터 에이전트의 과거 신뢰도에 따라 의견에 가중치를 주는 복잡한 방법까지 폭이 있다. 셋째, 설명 가능성을 우선해 토론의 추론과 중간 상태를 기록해야 한다. 최종 합의가 정확히 어떻게 도달됐는지 이해관계자가 이해할 수 있는 감사 추적이 된다.

P11

Agent Negotiation

협상 — 목표가 부딪칠 때

LV 6분산

맥락

저마다의 이해관계나 상충하는 목표를 가진 자율 에이전트 여럿이, 과업을 달성하거나 분쟁을 해소하기 위해 상호 수용 가능한 합의에 이르러야 한다.

문제와 힘

중앙 권위가 결과를 지시하지 않으면서, 자기 이익을 추구하는 에이전트들이 어떻게 상호 이익이 되는 합의에 이를 것인가. 고정되고 협상 불가한 접근은 교착이나, 잠재적 “윈–윈”을 놓치는 차선의 결과를 낳는다.

  • 자율성 대 정렬 — 에이전트에게 자기 목표를 추구할 자유가 필요하지만, 개별의 성공이 집단 목표를 희생시켜서는 안 된다.
  • 공정성 대 효율 — 모두가 만족하는 “윈–윈”이 이상적이지만, 그런 합의에 드는 시간과 연산을 시의적절한 결정의 필요와 저울질해야 한다.
  • 전략적 행동 대 투명성 — 복잡한 협상 전략은 최적 결과를 낳을 수 있지만, 결정의 근거를 감사하고 사람에게 설명하기 어렵게 만든다.

해법

제안과 역제안을 주고받는 구조화된 대화 프로토콜을 제공한다. 게임 이론의 영향을 크게 받았으며, 에이전트를 자기 효용을 극대화하려는 합리적 행위자로 본다. 전형적 프로토콜은 개시(최초 제안) → 평가 → 응답(수락·거절·역제안)으로 이뤄지고, 합의에 이르거나 종료 조건을 만날 때까지 반복한다.

사례 — 공유 GPU 서버를 두고

AnalyticsAgent는 새벽 2시부터 2시간, 시간에 민감한 고우선순위 금융 모델을. TrainingAgent는 같은 시각부터 4시간, 일상적 저우선순위 재학습을 원한다.

01충돌 감지ResourceManagerAgent가 두 요청이 같은 시각임을 감지한다
02개시 — 양측에 충돌을 알리고 우선순위와 유연성을 밝히라고 요구한다
03응답 — 분석 {priority:high, duration:2h, flexibility:low} · 학습 {priority:low, duration:4h, flexibility:medium}
04평가와 제안 — 고우선순위를 우대하는 정책에 따라 학습 에이전트에게 새 시각을 제안하라고 요청한다
05역제안 — 학습 에이전트가 일정을 확인하고 타협안을 낸다. “미룰 수 있다. 분석 작업이 끝난 새벽 4시부터 4시간 하겠다.”
06합의 — 분석 02:00–04:00, 학습 04:00–08:00. 사람 개입 없이 우선순위를 존중한 새 일정이 나왔다
구현 예시 · Python
class ResourceManagerAgent:
    def handle_requests(self, request1, request2):
        if request1.time == request2.time:            # 충돌 감지
            # 어느 쪽이 저우선순위인지 판별한다
            if request1.priority < request2.priority:
                lower, higher = Agent1, Agent2
            else:
                lower, higher = Agent2, Agent1

            # 저우선순위 에이전트에게 새 시각을 제안하게 한다
            new_proposal = lower.propose_new_time()

            if self.is_conflict_resolved(new_proposal, higher.request):
                self.grant_slot(higher, higher.request.time)
                self.grant_slot(lower, new_proposal.time)
                return "Agreement Reached"
            return "Negotiation Failed"   # 폴백 또는 추가 라운드

class TrainingAgent:                            # 저우선순위
    def propose_new_time(self):
        new_time = "4:00 AM"
        print(f"I am lower priority. I can defer. I propose {new_time}.")
        return Proposal(time=new_time)

장점

  • 유연성 — 경직된 고정 정책보다 모든 당사자에게 더 나은 결과를 내는 유연하고 동적인 합의를 가능하게 한다.
  • 최적성 — 중앙 권위나 사전 프로그래밍된 규칙에는 보이지 않을 “윈–윈” 해법을 발견하게 한다.

단점

  • 시간과 복잡도 — 협상은 시간과 연산을 많이 쓰며, 합의에 이른다는 보장이 없다.
  • 보장의 부재 — 해법을 내지 못하고, 폴백 기제가 없으면 교착으로 이어진다.

구현 지침

명확한 종료 조건과 폴백 위치를 정의하라. 합의가 안 되면 어떻게 할 것인가. 에이전트에게는 플랜 B가 있어야 한다. 제안과 역제안의 전체 순서를 감사와 사람의 감독을 위해 기록하라.

P12

Resource Allocation

자원 배분 — 모자랄 때 누구부터인가

LV 5중앙~시장

맥락

네트워크 대역폭, 연산 능력, API 호출 할당량처럼 유한한 자원 풀을, 경합하는 필요를 가진 여러 에이전트에 분배해야 한다.

문제와 힘

한정된 자원을 경합하는 에이전트들에게 효율적이고 공정하며 전체 목표에 부합하게 어떻게 나눌 것인가. 명확한 전략이 없으면 경합·병목·성능 저하를 겪는다.

  • 처리량 대 공정성 — 고가치 과업을 우선해 생산성을 극대화하려 하지만, 저우선순위 에이전트가 영영 자원을 못 받는 기아 상태도 막아야 한다.
  • 중앙 통제 대 부담 — 중앙 할당자는 우선순위의 전역 시야와 일관성을 주지만, 에이전트와 요청이 늘면 병목이나 단일 실패 지점이 된다.
  • 예측 가능성 대 적응성 — 고정 규칙은 단순하고 예측 가능하지만, 과업 중요도의 동적 변화나 즉각적 재배분이 필요한 환경 변화를 반영하지 못한다.

해법 — 세 갈래

  • 중앙집중 할당자 — 관리자 같은 전담 에이전트가 시스템 우선순위와 자원 가용성의 전역 시야에 근거해 결정한다.
  • 경매 기제 — 에이전트가 내부 화폐나 우선순위 점수로 자원에 입찰하고, 최고가가 정해진 기간 동안 자원을 차지한다. 과업의 진짜 가치를 에이전트 스스로 수량화할 수 있을 때 유용하다.
  • 공정 분할 알고리즘 — 공정성이 최우선일 때, 어떤 에이전트도 남의 몫을 부러워하지 않는 분배를 계산한다.

사례 — 스마트 공장의 자율 이동 로봇 배분

01ProductionLine_A_Agent — 고우선순위. 핵심 부품 배송. 라인 정지가 임박했다고 경고한다
02WarehouseAgent — 저우선순위. 일상적 재고 순환 카운팅
03ShippingAgent — 중우선순위. 두 시간 뒤 출고를 위해 완제품을 하역장으로 이동
04판정 — 다음 가용 로봇을 즉시 생산라인에 배정해 값비싼 정지를 막는다. 이어 배송에 배정한다. 창고의 저우선순위 요청은 대기열에 넣어 상위 과업이 없고 로봇이 남을 때만 처리한다
구현 예시 · Python
class AMR_DispatcherAgent:
    def __init__(self):
        # 우선순위별 요청 대기열
        self.high_priority_queue   = []
        self.medium_priority_queue = []
        self.low_priority_queue    = []
        self.available_amrs        = [AMR1(), AMR2(), AMR3()]

    def receive_request(self, request):
        if   request.priority == "high":   self.high_priority_queue.append(request)
        elif request.priority == "medium": self.medium_priority_queue.append(request)
        else:                              self.low_priority_queue.append(request)
        self.dispatch()

    def dispatch(self):
        if not self.available_amrs:
            return                       # 지금은 가용 로봇이 없다

        # 최고 우선순위부터 처리한다
        for queue in (self.high_priority_queue,
                      self.medium_priority_queue,
                      self.low_priority_queue):
            if queue:
                task  = queue.pop(0)
                robot = self.available_amrs.pop(0)
                robot.assign_task(task)
                break

장점

  • 최적화 — 희소 자원이 가장 중요한 과업으로 향하게 해, 단지 가장 빠른 에이전트를 만족시키는 대신 시스템 전체 효용을 극대화한다.
  • 안정성 — 자원 경합, 교착, 경쟁 조건을 막아 시스템 크래시나 예측 불가한 행동을 예방한다.

단점

  • 부담 — 중앙 계산이든 분산 경매든 할당 과정이 실제 실행 전에 지연을 붙인다.
  • 기아의 위험 — 잘못 설계된 규칙은 저우선순위 에이전트가 영영 자원을 못 받게 만든다. 안전장치가 필요하다.

구현 지침

할당 로직은 투명하고 명시적이어야 한다. 우선순위든 입찰이든 공정성이든, 이 명료함이 디버깅과 설명 가능성의 열쇠다. 경매 기반 시스템이라면 에이전트가 진짜 가치를 입찰하도록 유도하는 규칙을 설계해야 한다. 유인 양립성이라 부르는 원칙이며, 에이전트가 필요를 왜곡해 이익을 취하는 일을 막는다. 아울러 할당 기제는 조건 변화에 적응할 수 있어야 하고, 더 중대한 과업이 생기면 저우선순위 과업을 선점할 수 있어야 한다.

P13

Conflict Resolution

충돌 해소 — 계획이 정면으로 부딪칠 때

LV 6중앙~분산

맥락

둘 이상의 에이전트가 상충하는 계획이나 목표를 가질 수 있다. 두 물류 에이전트가 같은 시각 같은 좁은 골목으로 트럭을 보내려 하는 식이다.

문제와 힘

교착, 안전하지 않은 상태, 차선의 결과를 피하려면 에이전트 사이의 불일치와 상충 계획을 어떻게 해소할 것인가.

  • 안전 대 운영 속도 — 상충 행동을 막으면 시스템 실패나 물리적 손상을 예방하지만, 감지·해소 과정이 지연을 더해 고빈도 운영을 늦춘다.
  • 중앙 권위 대 분산 민첩성 — 감독자는 결정적이고 일관된 해소를 주지만, 중앙 통제점에 의존하면 개별 에이전트의 반응성을 제약하는 병목이 된다.
  • 논리적 일관성 대 목표 달성 — 충돌 해소는 흔히 최소 한 에이전트가 계획을 포기하거나 수정하게 만든다. 넓은 시스템의 무결성을 지키는 대가로 특정 과업이 차선이 될 수 있다.

해법 — 네 갈래

01 · Hierarchical

위계적 해소

지정된 감독자가 상충하는 에이전트를 무시하고 결정을 부과할 권한을 갖는다. 가장 직접적이고 명확하며 예측 가능하다. 규제 준수·안전·감사 가능한 결정이 최우선인 기업 응용에서 기본 선택인 경우가 많다. 감독자가 단일 진리원으로 기능해 시스템이 우유부단이나 교착에 빠지는 것을 막는다.

02 · Policy-based

정책 기반 해소

특정 유형의 충돌을 자동으로 다스리는 사전 정의 정책을 둔다. “안전 필수 에이전트는 항상 효율 최적화 에이전트보다 우선한다” 같은 것이다. 해소가 결정론적이고 일관된다. 강력한 이유는 의사결정 로직을 외부화해, 각 에이전트의 내부 상태를 몰라도 사람이 시스템 행동을 이해·수정·감사할 수 있게 만든다는 데 있다.

03 · Negotiation

협상에 의한 해소

상충하는 에이전트들이 협상 패턴에 들어가 상호 수용 가능한 타협을 찾는다. “윈–윈”이나 “덜 잃는” 결과의 여지가 있고, 에이전트가 양보와 역제안 평가를 할 만큼 정교할 때 적합하다. 하향식 명령 대신 당사자가 직접 자기 목표에 가장 맞는 해법을 찾으므로, 경직된 정책보다 미묘하고 창의적인 해법이 나올 수 있다.

04 · Game-theoretic

게임 이론적 해소

매우 복잡한 시나리오에서 충돌을 형식적 게임으로 모델링한다. 각 에이전트의 가능한 행동에 보수나 비용을 배정하고, 어느 에이전트도 일방적으로 전략을 바꿔 이득을 볼 수 없는 내시 균형 같은 안정 결과를 찾는다. 연산 부담이 크지만, 개별의 자기 이익 추구에서 바람직한 협력 행동이 자연히 창발하도록 시스템을 설계할 수 있다.

사례 — 처리량과 공정성이 부딪칠 때

ThroughputAgent는 시간당 처리 건수라는 속도 KPI에 최적화돼 있고, FairnessAgent는 인구통계적 편향을 확인하는 연산 집약적 분석을 맡아 절차를 늦춘다.

01충돌 감지 — “배치를 승인 단계로 진행”과 “공정성 검토를 위해 배치 보류”가 상호 배타적 행동으로 중앙 감독자에 기록된다
02정책 기반 해소 — 감독자가 내부 정책을 조회해 협상 불가 규칙을 찾는다. 모든 대출 배치는 승인 단계 전에 FAIRNESS_PASSED 상태를 받아야 한다. 규제와 윤리 지침이 속도 KPI를 압도한다.
03해소 — 처리량 에이전트의 계획을 무효화하고 “중단하고 공정성 점검 완료를 기다려라”를 지시한다. 공정성 에이전트에는 진행 우선권을 확인해 준다
04계속 — 공정성 점검이 끝나 상태가 FAIRNESS_PASSED로 바뀌면 감독자가 처리량 에이전트의 재개를 허용한다
구현 예시 · Python
class SupervisorAgent:
    def __init__(self):
        # 정책이 교전 규칙을 정의한다
        self.POLICY_FRAMEWORK = {"FAIRNESS_CHECK_REQUIRED": True}

    def handle_proposed_plans(self, plan1, plan2):
        if self.is_conflicting(plan1, plan2):
            print("Conflict Detected!")

            # 정책 기반 해소를 적용한다
            if self.POLICY_FRAMEWORK["FAIRNESS_CHECK_REQUIRED"]:
                if plan1.action == "HOLD_FOR_FAIRNESS_REVIEW":
                    self.approve_plan(plan1)      # 공정성 계획이 우선
                    self.deny_plan(plan2, reason="Fairness check must complete first.")
                else:
                    self.approve_plan(plan2)
                    self.deny_plan(plan1, reason="Fairness check must complete first.")

    def is_conflicting(self, plan1, plan2):
        return plan1.target == plan2.target and plan1.action != plan2.action

장점

  • 일관성 — 시스템이 모순되거나 교착된 상태에 빠지지 않게 해 전체 운영의 무결성을 지킨다.
  • 안전 — 에이전트가 서로 방해하는 위험한 상황(물리적 로봇 충돌, 논리적 데이터 손상)을 예방한다.

단점

  • 지연 — 감지와 해소가 연산 부담을 얹어 응답 시간을 늦춘다.
  • 복잡도 — 가능한 모든 충돌 시나리오에 대해 견고한 정책이나 협상 프로토콜을 설계하는 일은 공학적 노력을 크게 늘린다.

구현 지침 — 네 가지 원칙

  • 충돌 감지가 첫걸음이다 — 해소하려면 먼저 감지해야 한다. 자주 과소평가되는 대목이다. 가장 직접적인 방법은 중앙 감독자가 모든 행동과 계획을 감시하는 것이다. 둘이 같은 유한 자원 사용 계획을 등록하면 즉시 플래그한다. 자원 잠금 기제나, 실행 전 의도한 행동을 공유 공간에 등록하게 하는 방법도 있다.
  • 설명 가능한 해소 — 감사 추적 — 충돌이 해소됐을 때 그냥 진행해서는 안 된다. 결정의 근거가 기록돼야 한다. 로그는 왜 그 해소가 선택됐는지 명확히 밝혀야 한다. “B의 계획이 A보다 승인된 이유는 정책 N이 안전 필수 과업의 최우선을 규정하기 때문이다.”
  • 정의된 에스컬레이션 경로 — 사람을 고리 안에 — 현실에는 자동 기제가 실패하거나 결론에 이르지 못하는 결정적이고 예기치 못한 상황이 늘 있다. 기업 시스템의 궁극적 폴백은 거의 언제나 사람이다. 충돌의 맥락을 검토해 최종 판단을 내릴 사람에게 필요한 모든 정보를 넘기도록 설계해야 한다.
  • 시뮬레이션으로 이해하라 — 배포 전에, 특히 복잡한 협상이나 게임 이론 모델을 쓴다면 다양한 조건에서 상호작용을 시뮬레이션하는 것이 결정적이다. 충돌 해소 전략을 스트레스 테스트해 잠재적 교착이나 바람직하지 않은 창발 행동을 식별한다.
06

Spatial coordination

편대 제어 — 조율은 공간에도 미친다

조율의 과제가 늘 목표나 데이터에 관한 것은 아니다. 때로는 에이전트 자신의 물리적(또는 논리적) 배열에 관한 것이다. 로보틱스나 복잡한 시뮬레이션에서, 한 무리가 특정 구조를 유지한 채 응집된 단위로 행동하는 능력이 성패를 가른다.

P14

Formation Control

편대 제어 — 이웃만 보고 전체를 이룬다

LV 6최분산

맥락

한 무리의 에이전트가 환경 속을 움직이거나 행동하면서 서로에 대해 특정한 물리적·논리적 구조를 유지해야 한다. 로보틱스, 복잡한 시뮬레이션, 통일된 집단 행동이 요구되는 상황에서 흔하다.

문제와 힘

각 에이전트의 정확한 위치를 지시하는 경직된 중앙 제어기 없이, 어떻게 집단 편대를 동적으로 유지할 것인가. 단일 리더에 의존하면 단일 실패 지점이 생기고 장애물이나 환경 변화에 적응하기 어렵다.

  • 전역 응집 대 국소 감지 — 무리는 특정한 전역 형태를 유지해야 하지만, 개별 에이전트는 대개 바로 이웃의 정보에만 접근할 수 있다.
  • 구조적 경직 대 장애물 회피 — 목적 달성을 위해 사전 정의된 편대를 유지해야 하지만, 개별 에이전트는 위험을 우회하거나 충돌을 피하려 그 구조에서 벗어날 자유도 있어야 한다.
  • 통신 지연 대 동기화 속도 — 정밀한 편대 제어는 빠른 갱신을 요구하지만, 고빈도 통신은 네트워크를 포화시키거나 배터리 구동 에이전트의 전력 소모를 늘린다.

해법

제어 로직을 분산해 무리가 자기조직하게 한다. 핵심 발상은 각 에이전트가 중앙 리더의 명령이 아니라 바로 이웃의 위치와 상태에 근거해 결정한다는 것이다. 각 에이전트에는 지정된 이웃으로부터의 원하는 거리와 방위를 규정하는 단순한 제어 법칙이 프로그래밍된다. 개별의 국소 반응이 편대를 타고 번져 집단적·창발적 반응을 낳으므로, 장애물과 환경 변화에 유연하게 적응한다.

사례 — 농업용 드론 무리

01편대 규칙 — 각 드론에 단순한 규칙 하나. “왼쪽 이웃의 오른쪽 10미터, 앞쪽 이웃과 정렬한 위치를 유지하라”
02협조 이동 — 선두가 전진하면 각자 이웃 위치에 근거해 속도와 위치를 끊임없이 조정하며 격자를 유지한다
03동적 적응 — 편대 한가운데의 Drone_C가 진로에 나무를 감지하고 자율적으로 감속해 우회한다
04자기조직 — 인접한 Drone_BDrone_D가 위치 변화를 감지해 충돌을 피하려 감속한다. 뒤의 드론도 간격 유지를 위해 감속한다
05재편Drone_C가 장애물을 벗어나면 지정 위치로 가속해 돌아가고, 이웃들이 이 보정을 감지해 자기 속도를 조정한다. 어떤 중앙 명령도 없이 완벽한 편대가 매끄럽게 회복된다
구현 예시 · Python
class DroneAgent:
    DESIGNATED_OFFSET = Vector(10, 0)     # 예: 오른쪽 10미터

    def control_loop(self):
        while True:
            # 1. 이웃의 위치를 감지한다
            neighbor_position = self.get_neighbor_position()
            my_position       = self.get_my_position()

            # 2. 이웃을 기준으로 원하는 위치를 계산한다
            desired_position = neighbor_position + self.DESIGNATED_OFFSET

            # 3. 현재와 원하는 위치의 오차를 계산한다
            position_error = desired_position - my_position

            # 4. 조정이 필요한지 확인한다
            if NORM(position_error) > TOLERANCE:
                # 5. 오차를 보정할 조정 벡터를 계산한다
                self.adjust_velocity(self.calculate_adjustment(position_error))
            else:
                self.maintain_velocity()

            # 장애물 회피 서브루프도 함께 돈다
            ...

장점

  • 확장성 — 결정이 국소적이므로 어느 단일 제어기의 연산 부하도 늘지 않은 채 수백, 수천 에이전트까지 편대를 키울 수 있다.
  • 회복력 — 개별 에이전트의 장애에 견고하다. 하나가 이탈하면 이웃들이 자연스럽게 빈자리를 메운다.

단점

  • 국소 최적 — 국소 정보로 행동하는 에이전트는 전역 계획자라면 쉽게 피할 복잡한 장애물(막다른 골목 같은)에 갇힐 수 있다.
  • 안정성 위험 — 제어 법칙을 잘못 조율하면 에이전트가 위치를 계속 과보정하는 진동이 생겨 편대가 떨린다.

구현 지침

먼저 이웃 발견이 요구된다. 에이전트는 관련 동료를 식별하고 상태를 추적할 신뢰할 만한 기제가 필요하다. 로컬 메시 네트워크 같은 저지연 직접 통신이나 공유 상태 표현의 관찰로 달성한다.

패턴의 핵심은 제어 법칙이다. 에이전트가 다른 이에 대해 위치를 조정하는 구체적 규칙이며, 편대가 안정을 유지하고 스트레스 아래에서 진동하거나 흩어지지 않도록 제어 이론의 원리로 신중히 설계해야 한다.

끝으로 물리 환경 배포에 앞서 이 제어 법칙을 시험하고 다듬는 데 시뮬레이션이 필수다. 집단 행동을 안전하고 비용 효율적으로 반복 개선할 수 있다.