본문으로 건너뛰기

에이전트 오케스트레이션 패턴

LLM 에이전트가 하나로는 못 하는 일을 여러 개로 나누는 오케스트레이션 패턴과 실패 전파·관측 설계를 정리합니다.

· 4분 읽기

에이전트 오케스트레이션 패턴

개요

작년에 이어 올해 에이전트를 프로덕션에 붙이면서 단일 에이전트로 모든 걸 처리하려다 실패한 경험을 여러 번 했습니다. 컨텍스트는 넘치고, 도구가 열몇 개가 되니 모델이 잘못된 도구를 고르고, 하나의 긴 실행이 중간에 틀어지면 전체가 폐기됩니다. 그래서 관심은 “더 똑똑한 에이전트 한 명”에서 “어떻게 나누고 어떻게 잇는가”로 옮겨갔습니다. 이 글은 그 과정에서 정리한 오케스트레이션 패턴 — 라우터, 파이프라인, 군집(멀티에이전트) — 과 실패 전파·관측에 대한 메모입니다.

라우터 패턴: 분기는 오케스트레이터가

가장 단순한 형태는 들어온 요청을 유형별 전문 에이전트로 나눠주는 라우터입니다. 고객 문의 분류, 코드 리뷰 봇의 언어별 처리 같은 과제에 잘 맞습니다. 각 에이전트는 자기 도구와 프롬프트만 가지므로 컨텍스트가 작고 선택지가 줄어 정확도가 올라갑니다.

ROUTES = {
    "refund": refund_agent,
    "delivery": delivery_agent,
    "bug_report": triage_agent,
}

def route(request: str):
    label = classifier(request)          # 작은 모델로 분류
    agent = ROUTES.get(label, fallback_agent)
    return agent.run(request)

핵심 설계 포인트는 두 가지입니다. 라우팅은 싼 모델·규칙으로 할 수 있으면 그렇게 하고, 분류 실패의 안전지대인 폴백 에이전트를 반드시 둡니다. 폴백이 없는 라우터는 분류 오류가 곧 시스템 오류가 됩니다.

파이프라인 패턴: 단계를 잇는다

두 번째는 산출물을 다음 단계의 입력으로 넘기는 파이프라인입니다. “문서 수집 → 요약 → 초안 작성 → 검수”처럼 단계가 선형이고 각 단계의 입출력이 검사 가능할 때 좋습니다. 각 단계를 별도 실행으로 나누면 컨텍스트가 누적되지 않고, 중간 결과를 검증해서 조기에 실패시킬 수 있습니다.

def pipeline(doc: str) -> str:
    sources = retriever(doc)                    # 결정론적 단계
    summary = summarizer.run(sources)           # LLM 단계
    assert has_citations(summary), "인용 누락"   # 게이트
    draft = writer.run(summary)
    return reviewer.run(draft)

파이프라인의 설계 규칙은 “게이트를 넣는다”입니다. 단계 사이에 산출물 검증(스키마, 필수 필드, 인용 존재)을 두면 다음 단계로 쓰레기가 흘러가는 것을 막을 수 있습니다. 중간 산출물이 이미 틀렸는데 마지막 단계의 화려한 프롬프트로는 복구되지 않습니다.

군집 패턴: 협업하는 멀티에이전트

가장 복잡한 형태는 여러 에이전트가 역할을 나눠 협업하는 군집입니다. 코드 생성 담당·리뷰 담당·테스트 담당을 분리해서 리뷰어가 반려하면 생성자가 다시 시도하는 루프를 만드는 식입니다. 실제로 이 구조에서 생성 품질이 눈에 띄게 좋아지는 걸 봤는데, 같은 모델이라도 역할 프롬프트와 보는 컨텍스트가 다르면 비판이 가능해지기 때문입니다.

def swarm(task: str, max_rounds: int = 3) -> str:
    code = coder.run(task)
    for _ in range(max_rounds):
        review = reviewer.run(code, task)
        if review.approved:
            return code
        if not reviewer_run_tests(review, code).passed:
            code = coder.run(task, feedback=review.comments)
    return escalate_to_human(task, code, review)

대신 군집은 비용이 배로 드는 패턴입니다. 라운드마다 전체 컨텍스트가 재구성되므로 토큰 소비가 선형 이상으로 늘고, “서로 합의 못 하고 무한 수정” 루프가 생길 수 있어 라운드 상한과 인간 에스컬레이션을 반드시 붙입니다. 저는 세 가지 패턴 중 군집은 최후 수단으로만 씁니다.

실패 전파: 어디까지 되감을 것인가

에이전트 시스템은 확률적 부품으로 만든 시스템이므로 실패는 상수가 아니라 변수입니다. 그래서 오케스트레이터의 핵심 책임은 실패를 어떻게 전파할지 정하는 것입니다.

  • 재시도는 멱등하게: 같은 요청 재시도가 부작용을 두 번 일으키지 않게, 외부 효과(이메일 발송, 결제)는 실행 전 확정 단계와 분리합니다.
  • 부분 실패의 경계: 파이프라인 중간 실패 시 처음부터 다시 돌리는지, 실패 단계만 재시도하는지 정해둬야 합니다. 저는 단계별 산출물을 저장해 두고 실패 지점부터 재시키는 체크포인트 방식을 씁니다.
  • 타임아웃과 상한: 라운드 수, 실행 시간, 비용에 상한을 두고 초과 시 명확한 실패로 종료합니다. 무한히 도는 에이전트는 느린 장애입니다.

관측: 트레이스 없이는 디버깅이 불가능하다

멀티에이전트 시스템에서 print 디버깅은 통하지 않습니다. 실행이 여러 에이전트에 걸쳐 있어서 “어느 단계에서 어긋났는지”를 사후에 재구성할 수 없기 때문입니다. 최소한으로 남겨야 하는 기록은 이렇습니다.

  • 요청별 트레이스 ID와 각 에이전트 호출의 스팬(입력 요약, 출력, 토큰·비용·지연).
  • 라우터의 분류 결과와 확신도. 분류 오류가 몰리는 지점이 곧 개선 지점입니다.
  • 게이트 통과/실패 기록. 어떤 게이트가 자주 실패하는지가 파이프라인의 약한 단계를 알려줍니다.

구조화 로그 몇 줄이면 충분합니다.

import structlog
log = structlog.get_logger()

def traced(agent, span_name: str):
    def run(*args, **kwargs):
        result = agent.run(*args, **kwargs)
        log.info("agent_span", agent=span_name,
                 tokens=result.usage.total_tokens,
                 status=result.status)
        return result
    return run

비용 관측도 함께 두는 게 좋습니다. 어느 에이전트가 토큰을 가장 많이 쓰는지 알아야 군집 패턴의 비용 문제를 데이터로 논의할 수 있습니다.

마무리

정리하면 에이전트 오케스트레이션은 라우터(분기) → 파이프라인(직렬) → 군집(협업) 순으로 복잡도가 올라가고, 비용과 디버깅 난이도도 함께 올라갑니다. 저의 기준은 “파이프라인으로 되면 군집을 쓰지 않는다”입니다. 그리고 어떤 패턴이든 실패 전파 규칙과 트레이싱을 먼저 설계하는 것, 이것이 프로토타입과 프로덕션의 차이를 만든다고 생각합니다.

Related