대규모 언어 모델 기반 태스크 플래닝

대규모 언어 모델 기반 태스크 플래닝

2025-12-07, G30DR

1. 서론: 인공지능의 진화와 자율 에이전트의 부상

인공지능(AI) 연구의 궁극적인 지향점은 인간의 개입 없이 스스로 목표를 설정하고, 복잡한 환경을 인식하며, 일련의 행동을 계획하고 실행하여 문제를 해결하는 인공 일반 지능(AGI)의 구현에 있다.1 과거의 AI 시스템은 특정 도메인에 국한된 규칙 기반 시스템이나, 사전에 정의된 행동 공간 내에서 최적화를 수행하는 강화 학습(Reinforcement Learning) 에이전트가 주류를 이루었다. 그러나 이러한 시스템은 비구조적이고 개방적인 환경(Open World)에서 유연하게 대처하는 데 한계를 보였다. 최근 대규모 언어 모델(Large Language Model, LLM)의 급격한 발전은 이러한 한계를 극복하고 자율 에이전트(Autonomous Agent) 연구의 새로운 패러다임을 제시하고 있다. LLM은 단순한 자연어 처리 도구를 넘어, 방대한 세계 지식(World Knowledge)과 논리적 추론(Reasoning) 능력을 바탕으로 에이전트의 ‘두뇌’ 역할을 수행하며, 인지적 계획(Cognitive Planning)의 중심축으로 자리 잡았다.2

본 보고서는 LLM을 활용한 태스크 플래닝(Task Planning)의 이론적 배경부터 최신 아키텍처, 구체적인 방법론, 그리고 직면한 기술적 난제들을 포괄적으로 분석한다. 특히 AutoGPT, BabyAGI, HuggingGPT와 같은 대표적인 에이전트 아키텍처의 작동 원리를 심층 해부하고, Chain of Thought(CoT), Tree of Thoughts(ToT), ReAct와 같은 추론 프레임워크가 어떻게 단순한 언어 모델을 문제 해결형 에이전트로 변모시키는지 고찰한다. 또한, 도구 사용(Tool Use)과 자기 수정(Self-Correction) 메커니즘이 에이전트의 신뢰성과 확장성에 미치는 영향을 분석함으로써, 현재 기술의 도달점과 향후 연구 방향을 제시한다.

graph TD
subgraph Past_AI ["과거의 AI 시스템"]
RuleBased["규칙 기반 시스템 (특정 도메인 국한)"]
RL_Agent["강화 학습 에이전트 (사전 정의된 행동 공간)"]
end

subgraph Limitations ["한계점"]
Limit1["비구조적 환경 대응 불가"]
Limit2["유연성 부족"]
end

subgraph Current_Paradigm ["현재: LLM 기반 자율 에이전트"]
LLM_Brain["LLM (에이전트의 두뇌)"]
OpenWorld["개방형 환경 (Open World) 대응"]
Capabilities["세계 지식 + 논리적 추론"]
end

RuleBased --> Limit1
RL_Agent --> Limit2
Limit1 --> LLM_Brain
Limit2 --> LLM_Brain

LLM_Brain --> OpenWorld
LLM_Brain --> Capabilities

2. LLM 기반 자율 에이전트의 이론적 프레임워크

2.1 에이전트 구성의 4대 핵심 모듈

LLM 기반 자율 에이전트는 단일 모델이 아닌, 여러 기능적 모듈이 유기적으로 결합된 시스템으로 이해해야 한다. 학계의 연구를 종합하면, 이 시스템은 크게 프로파일(Profile), 기억(Memory), 계획(Planning), 행동(Action)이라는 네 가지 핵심 요소로 구성된다.4

첫째, 프로파일(Profile) 모듈은 에이전트의 페르소나, 역할, 목표를 정의한다. 이는 에이전트가 특정 도메인 전문가(예: 코딩 전문가, 창의적 작가)처럼 행동하도록 유도하거나, 장기적인 목표를 지속적으로 상기시키는 역할을 한다.

둘째, 기억(Memory) 모듈은 에이전트가 과거의 경험을 저장하고 검색하여 현재의 의사결정에 활용하게 한다. LLM의 컨텍스트 윈도우(Context Window) 제한을 극복하기 위해, 단기 기억(Short-term Memory)은 현재의 대화 흐름을 유지하는 데 사용되며, 장기 기억(Long-term Memory)은 벡터 데이터베이스(Vector Database) 등을 통해 방대한 정보를 저장하고 유사도 검색(Similarity Search)을 통해 필요한 시점에 인출(Retrieval)하는 방식으로 구현된다.5 이는 인간의 해마(Hippocampus)가 수행하는 일화적 기억(Episodic Memory) 기능과 유사한 역할을 수행한다.

셋째, 계획(Planning) 모듈은 에이전트의 인지적 중추로서, 복잡하고 추상적인 목표를 구체적이고 실행 가능한 하위 태스크(Sub-goal)로 분해하고 순서를 정하는 과정이다. 본 보고서의 핵심 주제인 이 모듈은 LLM의 추론 능력을 극대화하여 미지의 상황에서도 논리적인 행동 시퀀스를 생성한다.1

넷째, 행동(Action) 모듈은 계획된 내용을 실제 환경에서 수행하는 인터페이스다. 이는 텍스트 출력뿐만 아니라, API 호출, 웹 검색, 코드 실행 등 외부 도구(External Tools)와의 상호작용을 포함하며, 이를 통해 에이전트는 물리적 또는 디지털 세계에 실질적인 영향을 미친다.4

graph TD
Agent["LLM 기반 자율 에이전트"]

subgraph Profile_Module ["프로파일 (Profile)"]
P1["페르소나/역할 정의"]
P2["목표 설정"]
end

subgraph Memory_Module ["기억 (Memory)"]
M1["단기 기억: 대화 컨텍스트"]
M2["장기 기억: 벡터 DB / 유사도 검색"]
end

subgraph Planning_Module ["계획 (Planning)"]
PL1["하위 태스크 분해"]
PL2["순서 결정 및 추론"]
end

subgraph Action_Module ["행동 (Action)"]
A1["텍스트 출력"]
A2["외부 도구 (API, 웹검색 등)"]
end

Agent --> Profile_Module
Agent --> Memory_Module
Agent --> Planning_Module
Agent --> Action_Module

Planning_Module -->|"지시"| Action_Module
Action_Module -->|"경험/결과"| Memory_Module
Memory_Module -->|"컨텍스트 참조"| Planning_Module
Profile_Module -->|"행동 가이드"| Agent

graph TD
Input["현재 사용자 입력/쿼리"]

subgraph Memory_Process ["기억 인출 프로세스"]
ShortTerm["단기 기억 (대화 흐름 유지)"]

subgraph LongTerm_Mechanism ["장기 기억 메커니즘"]
VectorDB[("벡터 데이터베이스 (Vector DB)")]
Embedding["임베딩 (벡터화)"]
SimSearch["유사도 검색 (Similarity Search)"]
end

Retrieval["관련 정보 인출 (Retrieval)"]
end

Context["최종 컨텍스트 (입력 + 기억)"]

Input --> ShortTerm
Input --> Embedding
Embedding --> SimSearch
VectorDB -- "과거 경험 데이터" --> SimSearch
SimSearch --> Retrieval

ShortTerm --> Context
Retrieval --> Context

2.2 태스크 플래닝의 수학적 정식화 및 접근법

플래닝은 주어진 환경 E, 행동 공간 A, 목표 g에 대해, 목표를 달성할 수 있는 행동의 시퀀스 p = (a_0, a_1,..., a_t)를 생성하는 함수로 정의될 수 있다.3 전통적인 계획 수립 방식인 PDDL(Planning Domain Definition Language)은 상태와 행동을 기호 논리로 엄격하게 정의해야 했기에, 유연성이 부족하고 도메인 전문가의 수작업이 필요했다. 반면, LLM 기반 플래닝은 자연어를 매개로 하여 불확실성이 높은 환경에서도 일반화된 지식을 통해 확률적으로 가장 적절한 행동 a_t를 추론한다.

태스크 분해(Task Decomposition) 방식은 크게 두 가지로 나뉜다.7

  1. 계획 후 실행(Plan-then-Execute): 에이전트가 실행 전에 전체 하위 목표의 시퀀스를 미리 생성한다. 예를 들어 “저녁 식사 준비“라는 목표에 대해 “재료 확인 -> 장보기 -> 요리 -> 서빙“이라는 전체 계획을 수립한 뒤 순차적으로 실행한다. 이 방식은 전체적인 논리적 일관성을 유지하는 데 유리하지만, 실행 도중 발생하는 예기치 못한 변수(예: 재료 품절)에 유연하게 대응하기 어렵다는 단점이 있다.
  2. 반복적 분해(Iterative Decomposition) 및 인터리빙(Interleaving): 각 단계의 실행 결과를 관찰한 후, 그 시점에 필요한 다음 하위 목표를 동적으로 생성한다. 이는 환경 변화에 대한 적응력이 뛰어나지만, 장기적인 관점에서 목표가 표류(Drift)하거나 비효율적인 경로를 선택할 위험이 있다.7
graph TD
Start["사용자 목표 입력"]

subgraph Plan_then_Execute ["계획 후 실행 (Plan-then-Execute)"]
PE1["전체 계획 수립 (a_0 ... a_t)"]
PE2["순차적 실행"]
PE3["완료"]
PE1 --> PE2 --> PE3
end

subgraph Iterative_Decomposition ["반복적 분해 (Iterative Decomposition)"]
ID1["현재 상태 관찰"]
ID2["다음 단계 행동 생성 (a_t)"]
ID3["행동 실행"]
ID4["결과 확인"]
ID1 --> ID2 --> ID3 --> ID4
ID4 -->|"목표 미달성 시"| ID1
end

Start --> PE1
Start --> ID1

3. 심층 추론 및 계획 전략 (Advanced Prompting & Reasoning)

단순한 입출력(Input-Output) 매핑만으로는 복잡한 계획을 수립할 수 없다. LLM의 추론 능력을 증폭시키기 위해 다양한 프롬프트 엔지니어링 및 추론 프레임워크가 개발되었다.

3.1 Chain of Thought (CoT): 선형적 추론의 힘과 한계

Chain of Thought(CoT)는 복잡한 문제를 중간 단계의 논리적 추론 과정(Rationale)으로 분해하여 해결하는 기법이다. “단계별로 생각해보자(Let’s think step by step)“라는 유도 문구를 통해 모델이 최종 답안을 내기 전에 논리적 근거를 생성하도록 한다.8

CoT의 핵심은 문제 해결 과정을 투명하게 만들고 추적 가능하게 한다는 점이다. 수학적 문제나 상식 추론 과제에서 CoT는 괄목할 만한 성능 향상을 이끌어냈다. 그러나 CoT는 본질적으로 선형적(Linear) 구조를 가진다. 즉, 하나의 사고 흐름이 일직선으로 진행되므로, 초기에 잘못된 추론 단계를 밟을 경우 그 오류가 후속 단계로 전파(Error Propagation)되어 전체 결과가 오답으로 귀결되는 치명적인 약점이 있다.10 또한, 다양한 대안을 탐색하거나 막다른 길에 다다랐을 때 이전 단계로 돌아가는 백트래킹(Backtracking)이 불가능하다.

graph LR
Input["입력 질문"]

subgraph CoT_Process ["Chain of Thought"]
Step1["추론 단계 1"]
Step2["추론 단계 2 (오류 발생 가능)"]
Step3["추론 단계 3"]

Step1 --> Step2
Step2 -->|"오류 전파"| Step3
end

Output["최종 답변 (오답 가능성)"]

Input --> Step1
Step3 --> Output

3.2 Tree of Thoughts (ToT): 다중 경로 탐색과 전략적 의사결정

ToT는 CoT의 선형적 한계를 극복하고 인간의 문제 해결 방식인 시행착오와 탐색을 모사하기 위해 제안되었다. ToT 프레임워크에서 에이전트는 문제의 상태(State)를 노드로, 사고(Thought)를 엣지로 하는 트리 구조를 형성한다.8

ToT의 작동 방식은 다음과 같다. 각 단계에서 모델은 가능한 여러 개의 해결책(Thoughts)을 생성한다(Branching). 그리고 각 해결책이 목표 달성에 얼마나 유효한지 스스로 평가(Self-evaluation)한다. 이 평가를 바탕으로 유망한 경로는 유지하고, 가망이 없는 경로는 가지치기(Pruning)한다. 탐색 알고리즘으로는 너비 우선 탐색(BFS)이나 깊이 우선 탐색(DFS)이 사용된다. 예를 들어, ’24 게임(4개의 숫자를 사칙연산하여 24를 만드는 게임)’이나 창의적 글쓰기, 복잡한 전략 수립과 같이 높은 수준의 전방 탐색(Lookahead)과 전략적 판단이 필요한 과제에서 ToT는 CoT보다 월등한 성능을 보인다.8

graph TD
Root["문제 상태"]

Node1_1["생각 A"]
Node1_2["생각 B"]
Node1_3["생각 C"]

Root --> Node1_1
Root --> Node1_2
Root --> Node1_3

Eval1["평가: 유망함"]
Eval2["평가: 가망 없음 (Pruning)"]
Eval3["평가: 유망함"]

Node1_1 -.-> Eval1
Node1_2 -.-> Eval2
Node1_3 -.-> Eval3

Node2_1["후속 생각 A-1"]
Node2_2["후속 생각 C-1"]

Eval1 --> Node2_1
Eval3 --> Node2_2

Goal["목표 달성"]
Node2_1 --> Goal

3.3 ReAct (Reasoning + Acting): 행동과 추론의 통합 루프

ReAct는 추론(Reasoning)만으로는 외부 세계의 정보를 얻을 수 없고, 행동(Acting)만으로는 논리적 판단이 결여된다는 점에 착안하여 이 둘을 결합한 프레임워크다.8

ReAct 에이전트는 **생각(Thought) \rightarrow 행동(Action) \rightarrow 관찰(Observation)**의 루프를 반복한다.

  • 생각: 현재 상황을 분석하고 다음에 무엇을 해야 할지 추론한다.
  • 행동: 검색 엔진, 계산기, API 등 외부 도구를 사용하여 정보를 요청하거나 작업을 수행한다.
  • 관찰: 도구의 실행 결과(예: 검색 결과 텍스트)를 받아들여 컨텍스트를 업데이트한다.

이러한 순환 구조는 에이전트가 자신의 내부 지식에만 의존하여 발생하는 환각(Hallucination)을 줄이고, 실시간 정보에 기반한 정확한 계획 수립을 가능하게 한다.11 예를 들어, “현재 유럽에서 인구가 가장 많은 국가의 수도는 어디인가?“라는 질문에 대해, ReAct 에이전트는 먼저 인구 데이터를 검색(Action)하고, 그 결과(Observation)를 바탕으로 해당 국가의 수도를 다시 검색하는 식의 단계적 접근을 취한다.

프레임워크구조적 형태핵심 메커니즘장점단점 및 한계
Chain of Thought (CoT)선형 (Linear)단계별 논리 전개구현이 간단하며 수학/논리 문제에 효과적오류 전파 문제, 대안 탐색 불가
Tree of Thoughts (ToT)트리 (Tree)다중 경로 생성, 가지치기, 백트래킹전략적 의사결정, 복잡한 탐색 문제 해결높은 계산 비용, 많은 토큰 소모
ReAct루프 (Loop)추론-행동-관찰의 반복외부 정보 활용, 환각 감소, 동적 적응반복 실행으로 인한 시간 지연, 무한 루프 위험

4. 자율 에이전트 아키텍처 및 케이스 스터디

이론적 플래닝 모델들은 실제 소프트웨어 아키텍처로 구현되어 다양한 형태의 자율 에이전트로 발전했다. AutoGPT, BabyAGI, HuggingGPT는 각기 다른 철학과 구조를 통해 LLM의 계획 능력을 실증한다.

4.1 AutoGPT: 재귀적 자기 개선과 구조화된 사고

AutoGPT는 “GPT-4를 루프에 넣은 것“으로 묘사되며, 목표를 달성할 때까지 스스로 하위 태스크를 생성하고 실행하는 완전 자율성을 지향한다.13 AutoGPT의 가장 큰 특징은 고도로 구조화된 JSON 응답 포맷을 통한 엄격한 사고 과정 제어다. 에이전트는 매 턴마다 다음과 같은 필드를 포함하는 JSON 객체를 생성해야 한다.14

  • thoughts: 현재 상황에 대한 에이전트의 일반적인 생각.
  • reasoning: 왜 그러한 생각을 했는지에 대한 논리적 근거.
  • plan: 목표 달성을 위한 장기적인 계획을 불릿 포인트로 나열.
  • criticism: 자신의 계획이나 생각에 오류가 없는지 스스로 비판(Self-Criticism).
  • command: 실제 실행할 도구의 이름과 파라미터.

이러한 구조는 에이전트가 행동(Action)으로 넘어가기 전에 강제적으로 ’내적 독백(Internal Monologue)’을 수행하게 만든다.17 특히 criticism 필드는 에이전트가 과도한 확신(Overconfidence)을 가지거나 비효율적인 루프에 빠지는 것을 방지하는 안전장치 역할을 한다. 또한, 파일 시스템 접근이나 인터넷 검색과 같은 강력한 도구 사용 권한을 가짐으로써, 코드 작성부터 시장 조사까지 광범위한 태스크를 수행할 수 있다.

sequenceDiagram
participant Agent as 에이전트 (LLM)
participant Env as 환경/도구 (External Tools)

loop ReAct Loop
Agent->>Agent: "Thought: 현재 상황 분석 및 계획"
Agent->>Env: "Action: 도구 실행 (예: 검색)"
Env-->>Agent: "Observation: 실행 결과 반환"
Agent->>Agent: "Context Update: 정보 통합"
end
Agent->>Agent: "Final Answer: 최종 답변 도출"

4.2 BabyAGI: 상태 기반 태스크 관리와 우선순위화

BabyAGI는 AutoGPT와 유사하지만, **태스크 리스트(Task List)의 관리와 우선순위화(Prioritization)**에 아키텍처의 핵심을 둔다. 이는 마치 프로젝트 관리자가 업무를 조율하듯 작동한다.18 BabyAGI의 실행 루프는 세 가지 핵심 에이전트의 협업으로 이루어진다.20

  1. 실행 에이전트 (Execution Agent): 태스크 리스트의 최상단에 있는 작업을 가져와 수행한다. 이때 벡터 데이터베이스(Pinecone, Chroma 등)를 활용하여 이전 작업의 결과물이나 관련 컨텍스트를 검색하여 작업의 연속성을 보장한다.19
  2. 태스크 생성 에이전트 (Task Creation Agent): 방금 완료된 태스크의 결과와 전체 목표(Objective)를 분석하여, 목표 달성에 필요한 새로운 후속 태스크들을 생성한다. 이는 상황 변화에 따라 계획을 유동적으로 확장하는 단계다.
  3. 우선순위 에이전트 (Prioritization Agent): 새로 생성된 태스크와 기존에 대기 중인 태스크들을 모두 모아, 전체 목표와의 관련성 및 시급성에 따라 재정렬(Re-ranking)한다. 이 과정에서 이미 완료된 태스크는 제거되고, 중복된 태스크는 병합된다.21

BabyAGI의 이러한 구조는 상태 유지(Statefulness) 측면에서 강점을 가진다. 태스크 리스트 자체가 에이전트의 현재 상태를 대변하며, 지속적인 우선순위 재조정 로직(Reprioritization Logic)은 에이전트가 장기적인 실행 과정에서 목표를 잃고 표류하는 것을 방지하고, 항상 가장 중요한 작업에 집중하도록 강제한다.

graph TD
TaskList[("태스크 리스트 (Task List)")]
VectorDB[("벡터 DB (Context)")]

subgraph Execution_Loop ["실행 루프"]
Agent_Exec["실행 에이전트 (Execution Agent)"]
Agent_Create["태스크 생성 에이전트 (Task Creation Agent)"]
Agent_Prio["우선순위 에이전트 (Prioritization Agent)"]
end

TaskList -->|"1. 최상위 태스크 추출"| Agent_Exec
VectorDB -->|"컨텍스트 검색"| Agent_Exec
Agent_Exec -->|"2. 태스크 수행 & 결과"| Agent_Create

Agent_Create -->|"3. 후속 태스크 생성"| Agent_Prio
TaskList -->|"기존 대기 태스크"| Agent_Prio

Agent_Prio -->|"4. 재정렬 및 리스트 업데이트"| TaskList
Agent_Exec -->|"결과 저장"| VectorDB

4.3 HuggingGPT (Jarvis): 멀티모달 전문가 모델의 오케스트레이션

HuggingGPT는 LLM을 단일 문제 해결자가 아닌, 수많은 전문가 모델(Expert Models)을 관리하는 **컨트롤러(Controller)**로 재정의한다. Hugging Face 플랫폼에 호스팅된 수십만 개의 특화된 모델(Vision, Speech, Video 등)을 LLM이 적재적소에 호출하여 복잡한 멀티모달 태스크를 수행한다.23 HuggingGPT의 워크플로우는 명확하게 4단계로 구분된다.25

  1. 태스크 플래닝 (Task Planning): 사용자의 요청을 분석하여 이를 해결 가능한 여러 개의 하위 태스크로 분해한다. 이때 태스크 간의 의존성(Dependency)과 리소스 흐름을 파악하여 실행 순서를 정의한다. 예를 들어 “이 이미지를 설명하고 그 설명을 음성으로 읽어줘“라는 요청은 ‘이미지 캡셔닝’ 태스크와 ‘텍스트-음성 변환(TTS)’ 태스크로 분해되며, TTS는 캡셔닝의 결과물에 의존하게 된다.
  2. 모델 선택 (Model Selection): 각 하위 태스크를 수행하는 데 가장 적합한 모델을 Hugging Face 라이브러리에서 선정한다. LLM은 모델의 설명(Description), 태스크 유형, 다운로드 수 등을 종합적으로 고려하여 최적의 전문가를 선발한다.
  3. 태스크 실행 (Task Execution): 선정된 모델들을 호출하여 실제 추론을 수행한다. 이 단계의 핵심 기술은 **리소스 의존성 해결(Resource Dependency Resolution)**이다. HuggingGPT는 <resource>-task_id와 같은 특수 토큰을 사용하여, 선행 태스크(task_id)의 결과물이 후행 태스크의 입력 파라미터로 정확히 전달되도록 동적으로 치환한다.24 서로 의존성이 없는 태스크들은 병렬로 실행되어 효율성을 높인다.
  4. 응답 생성 (Response Generation): 모든 모델의 실행 결과를 수집하여, LLM이 최종적으로 사용자에게 친화적인 답변으로 요약 및 통합한다.

이 아키텍처는 “언어를 만능 인터페이스(Language as a Universal Interface)“로 활용하여, 서로 다른 입출력 형식을 가진 이질적인 AI 모델들을 하나로 묶어내는 거대한 생태계를 구축했다는 점에서 의의가 크다.

sequenceDiagram
participant User as 사용자
participant LLM as LLM (Controller)
participant HF as Hugging Face (Expert Models)

User->>LLM: "요청: 이미지 설명하고 읽어줘"

rect rgb(240, 248, 255)
Note right of LLM: 1. 태스크 플래닝
LLM->>LLM: "분해: [이미지 캡셔닝] -> [TTS]"
LLM->>LLM: "의존성 파악"
end

rect rgb(255, 250, 240)
Note right of LLM: 2. 모델 선택
LLM->>LLM: "전문가 모델 선정 (설명, 다운로드 수 기준)"
end

rect rgb(240, 255, 240)
Note right of LLM: 3. 태스크 실행
LLM->>HF: "이미지 캡셔닝 모델 호출"
HF-->>LLM: "결과: 텍스트 캡션"
LLM->>HF: "TTS 모델 호출 (입력: 캡션)"
HF-->>LLM: "결과: 오디오 파일"
end

rect rgb(255, 240, 245)
Note right of LLM: 4. 응답 생성
LLM->>User: "최종 결과 및 요약 전달"
end

graph TD
UserReq["요청: 이 이미지를 설명하고 읽어줘"]

subgraph Task_Parsing ["태스크 분해 및 의존성 파악"]
Task1["태스크 1: 이미지 캡셔닝 (Image Captioning)"]
Task2["태스크 2: 텍스트-음성 변환 (TTS)"]

Dependency["의존성: Task 2는 Task 1의 결과가 필요"]
end

subgraph Execution_Flow ["리소스 치환 실행"]
Exec1["Task 1 실행"] --> Result1["결과: '고양이가 있다' (Text)"]

Placeholder["Task 2 입력: <resource>-task_1"]
Result1 -.->|"동적 치환 (Replacement)"| Placeholder

Placeholder --> Exec2["Task 2 실행 (입력: '고양이가 있다')"]
end

Exec2 --> Final["최종 오디오 파일 생성"]

Task1 --> Exec1
Task2 --> Placeholder
Dependency --> Placeholder

4.4 LangChain 및 LangGraph: 그래프 기반 상태 제어

LangChain은 이러한 에이전트 개발을 위한 프레임워크를 제공해왔으며, 초기에는 AgentExecutor라는 클래스를 통해 ReAct 방식의 루프를 캡슐화했다.12 그러나 복잡한 에이전트 로직을 다루기 위해 최근에는 LangGraph가 도입되었다. LangGraph는 에이전트의 흐름을 단순한 체인(Chain)이 아닌, 순환(Cycle)과 분기(Branching)가 가능한 그래프(Graph) 형태의 상태 머신(State Machine)으로 모델링한다.28 이를 통해 개발자는 특정 상황에서 인간의 개입을 요청하거나(Human-in-the-loop), 특정 도구를 강제로 호출하게 하는 등 에이전트의 비결정적(Non-deterministic) 행동을 세밀하게 제어할 수 있게 되었다.

graph TD
subgraph Legacy_Chain ["기존 LangChain (Linear)"]
LC_Start["시작"] --> LC_Step1["단계 1"]
LC_Step1 --> LC_Step2["단계 2"]
LC_Step2 --> LC_End["종료"]
end

subgraph LangGraph_Flow ["LangGraph (Cyclic & Branching)"]
LG_Start["시작"] --> LG_Node1["노드 1: 실행"]
LG_Node1 --> LG_Cond{"조건 확인 (분기)"}

LG_Cond -- "도구 필요" --> LG_Node2["노드 2: 도구 호출"]
LG_Node2 -->|"순환 (Cycle)"| LG_Node1

LG_Cond -- "사람 개입 필요" --> LG_Human["노드 3: Human-in-the-loop"]
LG_Human --> LG_Node1

LG_Cond -- "완료" --> LG_End["종료"]
end

5. 도구 사용(Tool Use) 및 외부 연결성

LLM이 물리적 세계나 디지털 환경과 상호작용하기 위해서는 ’도구’를 사용하는 능력이 필수적이다. 이를 구현하는 방식은 크게 학습 기반 접근과 프롬프트 기반 접근으로 나뉜다.

graph LR
Root["도구 사용 (Tool Use) 접근법"]

subgraph Training_Based ["학습 기반 (예: Toolformer)"]
TB_Method["방식: 모델 미세 조정 (Fine-tuning)"]
TB_Data["데이터: API 호출 예시가 포함된 텍스트"]
TB_Pros["장점: 호출 정확도 높음, 추론 비용 절감"]
TB_Feature["특징: 도구 사용 패턴의 내재화"]

TB_Method --> TB_Feature
end

subgraph Prompt_Based ["프롬프트/검색 기반 (예: Gorilla, ReAct)"]
PB_Method["방식: 가중치 변경 없음 (No Weight Change)"]
PB_Data["데이터: API 문서 (Docs) + RAG"]
PB_Pros["장점: 방대한 API 처리 가능, 최신성 유지"]
PB_Feature["특징: 검색(Retrieval)과 스키마 활용"]

PB_Method --> PB_Feature
end

Root --> Training_Based
Root --> Prompt_Based

5.1 학습을 통한 내재화: Toolformer

Toolformer는 LLM이 별도의 지시 없이도 스스로 도구 사용 시점을 판단하고 API를 호출하도록 모델 자체를 **미세 조정(Fine-tuning)**하는 방식이다.30 연구진은 텍스트 데이터셋 내에 API 호출 예시(예: The result is)를 자동으로 생성하여 주입하고 이를 학습시켰다. 그 결과, Toolformer는 추론 과정에서 적절한 위치에 API 호출 토큰을 생성할 수 있게 되었다. 이 방식의 장점은 In-context learning을 위한 긴 예시 프롬프트가 필요 없어 추론 비용이 절감되고, 도구 사용 패턴이 모델의 가중치에 내재화되어 호출의 정확도가 높다는 점이다.

graph TD
Dataset["일반 텍스트 데이터셋"]

subgraph Data_Generation ["데이터 생성 단계"]
LLM_Base["기본 LLM"]
API_Sampling["API 호출 예시 샘플링"]
Filter["필터링: 유용한 호출만 선별"]
end

Result_Data["증강된 데이터셋 (텍스트 + API 호출)"]
Fine_Tuning["미세 조정 (Fine-tuning)"]
Toolformer["Toolformer 모델 완성"]

Dataset --> LLM_Base
LLM_Base --> API_Sampling
API_Sampling --> Filter
Filter --> Result_Data
Result_Data --> Fine_Tuning
Fine_Tuning --> Toolformer

5.2 프롬프팅 및 검색 기반 접근: Gorilla 및 ReAct

반면, Gorilla나 ReAct는 모델의 가중치를 변경하지 않고 프롬프트를 통해 도구를 사용한다. Gorilla는 방대한 API 문서(API Documentation)를 학습하여, 사용자의 자연어 요청을 정확한 API 호출 구문으로 변환하는 데 특화된 모델이다.33 이는 검색(Retrieval) 시스템과 결합하여 수천 개의 API 중 현재 필요한 것을 찾아내고, 올바른 파라미터를 채워 넣는 능력이 탁월하다.

최근 OpenAI의 함수 호출(Function Calling) 기능은 이러한 프롬프트 기반 도구 사용을 표준화했다.35 개발자가 도구의 기능을 JSON 스키마(JSON Schema)로 정의하여 제공하면, 모델은 이를 이해하고 실행이 필요할 때 해당 스키마에 맞는 구조화된 JSON 데이터를 생성한다. 이는 자연어 생성의 모호함을 제거하고 구문 오류(Syntax Error)를 획기적으로 줄여, 에이전트 시스템의 안정성을 크게 향상시켰다.36

sequenceDiagram
participant Dev as 개발자
participant User as 사용자
participant LLM as LLM (OpenAI)
participant App as 애플리케이션/API

Dev->>LLM: "도구 정의 (JSON Schema 제공)"
User->>LLM: "자연어 요청 (예: 부산 날씨 어때?)"

rect rgb(240, 248, 255)
Note right of LLM: 의도 파악 및 구조화
LLM->>LLM: "도구 사용 필요성 판단"
LLM-->>App: "JSON 출력: {func: getWeather, loc: Busan}"
end

rect rgb(255, 250, 240)
Note right of App: 실행 및 결과 반환
App->>App: "API 실행 (구문 오류 없음)"
App-->>LLM: "실행 결과: 섭씨 20도"
end

LLM->>User: "최종 답변: 부산은 현재 20도입니다."

6. 인지적 정제: 자기 수정(Self-Correction)과 성찰

LLM은 종종 확신에 찬 어조로 틀린 정보를 생성하는 환각(Hallucination)을 일으키거나, 계획 실행 도중 오류를 범하기 쉽다. 따라서 생성된 계획과 결과를 스스로 검증하고 수정하는 메커니즘은 자율 에이전트의 신뢰성을 담보하는 핵심 기술이다.

6.1 Reflexion: 언어적 강화 학습

Reflexion 프레임워크는 전통적인 강화 학습(RL)에서 사용하는 수치적 보상(Scalar Reward) 대신, **언어적 피드백(Verbal Feedback)**을 사용하여 에이전트를 최적화한다.37 Reflexion의 과정은 다음과 같다.

  1. Actor: 환경에서 행동을 수행하고 궤적(Trajectory)을 생성한다.
  2. Evaluator: 수행 결과의 성공 여부를 평가한다.
  3. Self-Reflection: 실패했을 경우, 그 원인을 분석하여 언어적인 ’교훈(Lesson)’이나 ’비판(Critique)’을 생성하고 이를 장기 기억에 저장한다.
  4. Next Attempt: 다음 시도 시, 저장된 교훈을 컨텍스트로 함께 입력받아 이전의 실수를 반복하지 않도록 행동을 수정한다.

이 방식은 모델의 파라미터를 업데이트하지 않고도(In-context), 에이전트가 경험을 통해 학습하고 성능을 개선할 수 있는 효율적인 방법이다.

graph TD
Start["태스크 시작"] --> Actor["Actor (행동 수행)"]
Actor --> Trajectory["궤적 (Trajectory) 생성"]
Trajectory --> Evaluator["Evaluator (성공 여부 평가)"]

Evaluator -- "성공" --> Success["태스크 완료"]
Evaluator -- "실패" --> Self_Reflection["Self-Reflection (자기 성찰)"]

Self_Reflection -->|"오류 분석 및 교훈 생성"| Memory[("장기 기억 (Long-term Memory)")]
Memory -->|"교훈을 컨텍스트로 주입"| Actor

style Success fill:#d4edda,stroke:#28a745
style Self_Reflection fill:#f8d7da,stroke:#dc3545

6.2 CRITIC 및 Self-Refine

Self-Refine은 에이전트가 자신의 결과물을 스스로 비판(Critique)하고 수정(Refine)하는 과정을 반복하여 품질을 높이는 방법이다.39 그러나 에이전트 자체의 지식이 잘못된 경우, 잘못된 비판으로 인해 결과가 오히려 악화될 수 있다. 이를 보완하기 위해 CRITIC 프레임워크는 내부적인 자기 비판에만 의존하지 않고, 코드 인터프리터, 사실 검증 API, 시뮬레이터 등 **외부 도구(External Tools)**를 사용하여 결과물의 유효성을 객관적으로 검증한다.40 검증 결과 발견된 오류는 피드백으로 에이전트에 전달되어 계획을 수정하는 데 사용된다.

graph TD
Input["문제 입력"] --> Gen["초기 답변 생성"]

subgraph Verification_Loop ["검증 루프 (CRITIC)"]
Gen --> Tool_Interact["외부 도구 상호작용 (코드 실행, 검색 등)"]
Tool_Interact --> Observe["결과 관찰"]
Observe --> Compare{"결과와 답변 비교"}

Compare -- "오류 발견 (Criticism)" --> Feedback["피드백 생성"]
Feedback --> Refine["답변 수정 (Refine)"]
Refine --> Tool_Interact
end

Compare -- "검증 통과" --> Final["최종 답변 출력"]

graph TD
Start["초안 생성 (Initial Generation)"]

subgraph Refinement_Loop ["자기 정제 루프 (Self-Refine)"]
Feedback["Self-Critique: 스스로 비판 (내부 지식 기반)"]
Refinement["Self-Refine: 비판 반영하여 수정"]
Check{"만족스러운가?"}

Start --> Feedback
Feedback --> Refinement
Refinement --> Check
Check -- "No (품질 미달)" --> Feedback
end

Check -- "Yes (완료)" --> Final["최종 결과물"]

7. 주요 과제 및 한계점

LLM 기반 태스크 플래닝은 비약적인 발전에도 불구하고 여전히 실용화를 위해 해결해야 할 심각한 과제들을 안고 있다.

7.1 환각(Hallucination)과 오류 전파의 심화

에이전트 시스템에서 환각은 텍스트 생성 오류보다 훨씬 치명적이다. 잘못된 계획이나 도구 사용은 시스템 전체의 오작동을 유발하기 때문이다. 에이전트 환각은 크게 세 가지로 분류된다.42

  • 지각 환각(Perception Hallucination): 환경 정보를 잘못 받아들이거나 해석하는 오류.

  • 추론 환각(Reasoning Hallucination): 논리적 비약이나 잘못된 인과관계 설정으로 인해 결함 있는 계획을 수립하는 오류.

  • 실행 환각(Execution Hallucination): 도구 사용법을 잘못 알고 있거나 의도하지 않은 행동을 수행하는 오류.

특히, 계획의 초기 단계에서 발생한 사소한 환각은 태스크가 진행됨에 따라 연쇄적으로 증폭되어(Cascading Error), 최종 결과물을 완전히 엉뚱한 방향으로 이끌 수 있다.

mindmap
root(("에이전트 환각 (Hallucination)"))
Type1("지각 환각 (Perception)")
Description("환경 정보 오인")
Example("이미지/텍스트 오독")
Type2("추론 환각 (Reasoning)")
Description("논리적 비약")
Example("잘못된 인과관계 설정")
Type3("실행 환각 (Execution)")
Description("도구 오사용")
Example("존재하지 않는 API 호출")
Consequence("오류 전파 (Cascading Error)")
Process("초기 사소한 오류 -> 최종 결과 붕괴")

7.2 장기 계획(Long-Horizon Planning)의 실패

태스크의 단계가 길어질수록 에이전트는 원래의 목표를 잊어버리거나(Context Loss), 맥락에서 벗어난 행동을 하는 경향이 있다.43 이는 LLM의 제한된 컨텍스트 윈도우와 확률적 모델의 특성상, 단계가 거듭될수록 정답 경로에서 이탈할 확률이 누적되기 때문이다. BabyAGI의 우선순위 재조정이나 벡터 DB를 활용한 기억 관리가 대안으로 제시되지만, 매우 복잡하고 긴 호흡의 과제에서는 여전히 인간 수준의 일관성을 유지하기 어렵다.45

graph TD
Goal["원래 목표 (Target)"]

subgraph Execution_Steps ["실행 단계별 확률 누적"]
Step1["Step 1: 성공 (오차 없음)"]
Step5["Step 5: 미세한 오차 발생 (Slight Drift)"]
Step10["Step 10: 환각 발생 (Hallucination)"]
Step20["Step 20: 목표 망각 (Context Loss)"]

Step1 --> Step5
Step5 --> Step10
Step10 -->|"오류 증폭"| Step20
end

Step1 -.-> Goal
Step20 -.->|"완전히 빗나감"| Fail["실패 / 엉뚱한 결과"]

style Step20 fill:#ffcccc,stroke:#ff0000
style Fail fill:#ffcccc,stroke:#ff0000

7.3 멀티 에이전트 조정(Coordination)의 난제

단일 에이전트의 한계를 극복하기 위해 멀티 에이전트 시스템이 도입되고 있으나, 에이전트 간의 **지식 불일치(Knowledge Inconsistency)**가 새로운 문제로 대두된다.46 서로 다른 데이터 소스나 컨텍스트를 가진 에이전트들이 협업할 때, 상충되는 정보를 기반으로 의사결정을 내려 충돌이 발생하거나 무한 루프에 빠지는 현상이 보고되고 있다.

sequenceDiagram
participant AgentA as 에이전트 A (데이터 소스 X)
participant AgentB as 에이전트 B (데이터 소스 Y)
participant System as 전체 시스템

Note over AgentA, AgentB: 지식 불일치 상황 (Knowledge Inconsistency)

AgentA->>AgentB: "계획 제안: 경로 1로 가자 (소스 X 기반)"
AgentB-->>AgentA: "거절: 경로 1은 막혔음 (소스 Y 기반)"

AgentA->>AgentB: "재제안: 그럼 경로 1 우회하자"
AgentB-->>AgentA: "거절: 우회로는 너무 위험함"

loop Coordination Failure
AgentA->>AgentB: "서로 상충되는 제안 반복"
AgentB-->>AgentA: "합의 실패"
end

System->>System: "무한 루프 또는 실행 정지"

8. 결론 및 미래 전망

LLM 기반 태스크 플래닝은 기호적 AI의 논리성과 신경망 AI의 유연성을 결합하는 거대한 실험이다. AutoGPT와 BabyAGI가 보여준 자율성의 가능성, HuggingGPT가 증명한 도구 연결성, 그리고 Reflexion이 제시한 자기 개선 능력은 차세대 AI 에이전트의 청사진을 명확히 보여준다.

향후 연구는 1) 환각을 통제하고 신뢰성을 보장하기 위한 엄격한 검증 모듈(Verification Module)의 통합, 2) 무한한 컨텍스트를 효율적으로 관리하고 장기 기억을 구조화하는 메모리 아키텍처의 혁신, 3) 에이전트 간의 효율적인 협업을 위한 표준화된 통신 프로토콜 정립에 집중될 것으로 전망된다. 더 나아가, 단순히 텍스트 예측을 넘어 자신의 행동이 가져올 결과를 시뮬레이션하고 예측하는 **세계 모델(World Model)**의 도입은 에이전트가 진정한 의미의 계획 능력을 갖추게 하는 결정적인 열쇠가 될 것이다. LLM은 이제 정보를 처리하는 도구를 넘어, 현실 세계의 문제를 해결하기 위해 스스로 생각하고, 계획하고, 행동하는 주체적인 인지 시스템으로 진화하고 있다.

graph TD
Agent["LLM 에이전트"]
Action_Candidate["행동 후보 생성"]

subgraph World_Model_Sim ["세계 모델 (World Model) 시뮬레이션"]
Sim["가상 시뮬레이션 수행"]
Predict["미래 상태/결과 예측"]
end

Eval{"예측 결과 평가"}
Real_Env["현실 세계 (Real World)"]

Agent --> Action_Candidate
Action_Candidate --> Sim
Sim --> Predict
Predict --> Eval

Eval -- "부정적 결과 예측" --> Agent
Eval -- "긍정적 결과 예측" --> Real_Env

%%note right of Agent: 계획 수정 (Re-planning)%%
%%note right of Real_Env: 실제 행동 실행%%

9. 참고 자료

  1. A Survey on Large Language Model based Autonomous Agents - arXiv, https://arxiv.org/html/2308.11432v6
  2. LLM Powered Autonomous Agents | Lil’Log, https://lilianweng.github.io/posts/2023-06-23-agent/
  3. arXiv:2402.02716v1 [cs.AI] 5 Feb 2024, https://arxiv.org/pdf/2402.02716
  4. Taxonomy on LLM-Agent planning. | Download Scientific Diagram - ResearchGate, https://www.researchgate.net/figure/Taxonomy-on-LLM-Agent-planning_fig1_380756642
  5. [2402.02716] Understanding the planning of LLM agents: A survey - arXiv, https://arxiv.org/abs/2402.02716
  6. xinzhel/LLM-Agent-Survey: Survey on LLM Agents (Published on CoLing 2025) - GitHub, https://github.com/xinzhel/LLM-Agent-Survey
  7. Towards Goal-oriented Large Language Model Prompting: A Survey - arXiv, https://arxiv.org/html/2401.14043v1
  8. Mastering Advanced Prompting: Tree of Thought, ReAct, and Chain …, https://www.technobillion.ai/post/mastering-advanced-prompting-tree-of-thought-react-and-chain-of-thought
  9. Chain of Thought (COT), Tree of Thought (TOT), and ReAct (Response & Act) | by Sujatha Mudadla | Medium, https://medium.com/@sujathamudadla1213/chain-of-thought-cot-tree-of-thought-tot-and-react-response-act-6d8103f52a48
  10. What is Tree Of Thoughts Prompting? - IBM, https://www.ibm.com/think/topics/tree-of-thoughts
  11. Comparing Reasoning Frameworks: ReAct, Chain-of-Thought, and Tree-of-Thoughts | by allglenn | Stackademic, https://blog.stackademic.com/comparing-reasoning-frameworks-react-chain-of-thought-and-tree-of-thoughts-b4eb9cdde54f
  12. LangChain Agent Executor Deep Dive - Aurelio AI, https://www.aurelio.ai/learn/langchain-agent-executor
  13. Beyond ChatGPT: The Rise of AI Agents - GreenNode, https://greennode.ai/blog/beyond-chatgpt-the-rise-of-ai-agents
  14. [Long read] Deep dive into AutoGPT: A comprehensive and in-depth step-by-step guide to how it works - DEV Community, https://dev.to/airtai/long-read-deep-dive-into-autogpt-a-comprehensive-and-in-depth-step-by-step-guide-to-how-it-works-48gd
  15. AI Agents: AutoGPT architecture & breakdown | by George Sung - Medium, https://medium.com/@georgesung/ai-agents-autogpt-architecture-breakdown-ba37d60db944
  16. Dissecting Auto-GPT’s prompt - OpenAI Developer Community, https://community.openai.com/t/dissecting-auto-gpts-prompt/163892
  17. Decoding Auto-GPT - Maarten Grootendorst, https://www.maartengrootendorst.com/blog/autogpt/
  18. What is BabyAGI? - IBM, https://www.ibm.com/think/topics/babyagi
  19. The Rise of BabyAGI - Emergence - Beehiiv, https://emergence-ai.beehiiv.com/p/rise-babyagi
  20. yoheinakajima/babyagi - GitHub, https://github.com/yoheinakajima/babyagi
  21. Decoding BabyAGI: Unraveling Task-Driven Autonomy | by Akshat Singh | Medium, https://medium.com/@akshat.singh1718/decoding-babyagi-unraveling-task-driven-autonomy-f6002dbd659c
  22. Meet BabyAGI — The Autonomous AI Agent to Streamline Your Tasks | Towards AI, https://towardsai.net/p/generative-ai/meet-babyagi-the-autonomous-ai-agent-to-streamline-your-tasks
  23. HuggingGPT: Solving Complex AI Tasks by Connecting LLMs to Specialized Models, https://neuralnotes.tech/hugginggpt-solving-complex-ai-tasks-by-connecting-llms-to-specialized-models-ba3af0decc4a
  24. HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face - arXiv, https://arxiv.org/pdf/2303.17580
  25. HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in …, https://arxiv.org/abs/2303.17580
  26. HuggingGPT - Solving AI Tasks with ChatGPT - Learn Prompt, https://www.learnprompt.pro/docs/llm-agents/hugginggpt/
  27. HuggingGPT: A New Way to Solve Complex AI Tasks with Language - Kenovy, https://kenovy.com/hugginggpt-a-new-way-to-solve-complex-ai-tasks-with-language/
  28. Agents - Docs by LangChain, https://docs.langchain.com/oss/python/langchain/agents
  29. LangGraph - LangChain Blog, https://blog.langchain.com/langgraph/
  30. Toolformer: Language Models Can Teach Themselves to Use Tools - OpenReview, https://openreview.net/forum?id=Yacmpz84TH
  31. ToolFormer: Guiding AI Models To Use External Tools | Towards Data Science, https://towardsdatascience.com/toolformer-guiding-ai-models-to-use-external-tools-37e4227996f1/
  32. Giving LLMs the tools to be truly useful | by Roman Mayr - Medium, https://medium.com/@roman-mayr/giving-llms-the-tools-to-be-truly-useful-02cd1339094d
  33. Evolution of LLM: Tool Use - Medium, https://medium.com/@wydtroy/evolution-of-llm-tool-use-b5a9fe6de2cc
  34. Tools for Large Language Model Agents - Han Lee, https://leehanchung.github.io/blogs/2024/05/09/tools-for-llms/
  35. ToolRegistry: A Protocol-Agnostic Tool Management Library for Function-Calling LLMs, https://arxiv.org/html/2507.10593v1
  36. Unified Tool Integration for LLMs: A Protocol-Agnostic Approach to Function Calling - arXiv, https://arxiv.org/html/2508.02979v1
  37. Building a Self-Correcting AI: A Deep Dive into the Reflexion Agent with LangChain and LangGraph | by Vi Q. Ha | Medium, https://medium.com/@vi.ha.engr/building-a-self-correcting-ai-a-deep-dive-into-the-reflexion-agent-with-langchain-and-langgraph-ae2b1ddb8c3b
  38. Reflexion | Prompt Engineering Guide, https://www.promptingguide.ai/techniques/reflexion
  39. [D] Self-Refine vs Reflexion - which method is better for improving LLMs’ outputs quality?, https://www.reddit.com/r/MachineLearning/comments/1cfb2l5/d_selfrefine_vs_reflexion_which_method_is_better/
  40. The Lighthouse of Language: Enhancing LLM Agents via Critique-Guided Improvement, https://arxiv.org/html/2503.16024v2
  41. CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing, https://openreview.net/forum?id=Sx038qxjek
  42. LLM-based Agents Suffer from Hallucinations: A Survey of Taxonomy, Methods, and Directions - arXiv, https://arxiv.org/html/2509.18970v1
  43. LLM-based Agents Suffer from Hallucinations: A Survey of Taxonomy, Methods, and Directions - arXiv, https://arxiv.org/html/2509.18970v2
  44. LLMs as Planning Formalizers: A Survey for Leveraging Large Language Models to Construct Automated Planning Models - ACL Anthology, https://aclanthology.org/2025.findings-acl.1291.pdf
  45. Why do LLM-based agents fail at long-horizon planning in stochastic environments? : r/MLQuestions - Reddit, https://www.reddit.com/r/MLQuestions/comments/1pbmknp/why_do_llmbased_agents_fail_at_longhorizon/
  46. Multi-Agent AI Gone Wrong: How Coordination Failure Creates Hallucinations | Galileo, https://galileo.ai/blog/multi-agent-coordination-failure-mitigation