📄 Reflexion: Language Agents with Verbal Reinforcement Learning

📋 메타 정보

항목	내용
저자	Noah Shinn, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, Shunyu Yao
소속	Northeastern University (Khoury College), MIT, Princeton University
발표처	NeurIPS 2023 (37th Conference on Neural Information Processing Systems)
연도	2023
arXiv	2303.11366
GitHub	noahshinn/reflexion
OpenReview	vAElhFcKW6

---

🎯 한줄 요약

LLM 에이전트가 가중치 업데이트 없이 언어적 자기 성찰(verbal self-reflection)을 통해 실패 경험으로부터 학습하여 의사결정, 추론, 코딩 태스크에서 성능을 크게 향상시키는 새로운 강화학습 패러다임을 제시한다.

---

🔍 연구 배경 및 동기

기존 RL의 한계

1. 데이터 비효율성
   • 전통적인 강화학습(RL)은 방대한 양의 학습 샘플과 비용이 많이 드는 모델 파인튜닝이 필요
   • Policy gradient나 value-based 방법들은 extensive training과 expensive model fine-tuning 요구
2. 스칼라 보상의 한계
   • 기존 RL은 스칼라 또는 벡터 형태의 보상 신호를 사용
   • 정확한 credit assignment가 어려움 – 어떤 행동이 성공/실패에 기여했는지 파악 곤란
   • 구체적인 개선 방향 제시 불가능
3. 해석 불가능성
   • 정책 네트워크나 가치 함수의 학습 과정이 블랙박스
   • 에이전트가 왜 특정 행동을 선택했는지 파악하기 어려움
4. 인간 학습과의 괴리
   • 인간은 실패로부터 성찰(reflection)하고 다음 시도에서 개선된 계획을 세움
   • 기존 LLM 에이전트는 이러한 시행착오를 통한 자가 학습 능력이 부족

핵심 연구 질문

“LLM 에이전트가 가중치 업데이트 없이 trial-and-error를 통해 빠르고 효율적으로 학습할 수 있을까?”

---

💡 핵심 아이디어

1. Verbal Reinforcement Learning (언어적 강화학습)

기존 RL이 스칼라 보상을 사용하는 것과 달리, Reflexion은 언어적 피드백을 강화 신호로 사용:

Traditional RL: state → action → scalar reward → weight update
Reflexion:      state → action → verbal feedback → memory update (no weight change)

핵심 차별점:
– 가중치 업데이트 없음: LLM 파인튜닝 불필요
– 언어적 피드백: 스칼라 값 대신 자연어로 된 구체적 개선 방향 제공
– Semantic Gradient: 언어적 피드백이 일종의 “의미론적 그래디언트” 역할

2. Self-Reflection 메커니즘

에이전트가 실패한 후 자기 성찰을 통해 무엇이 잘못되었는지 분석하고, 이를 자연어로 저장:

실패한 태스크 → 자기 성찰 생성 → 메모리에 저장 → 다음 시도에서 활용

Self-Reflection의 역할:
– 실패 원인 분석 (What went wrong?)
– 구체적인 개선 방향 제시 (What to do differently?)
– 다음 시도에 활용할 교훈 생성

예시: 프로그래밍 태스크에서 실패 시

“함수가 음수 입력을 처리하지 못해 실패했습니다. 향후 시도에서는 음수 입력에 대한 체크 로직을 반드시 추가해야 합니다.”

3. 에피소딕 메모리 (Episodic Memory)

성찰 결과를 에피소드 메모리에 저장하여 후속 시도에서 참조:

메모리 유형	설명	저장 내용
단기 메모리 (Short-term)	현재 에피소드의 trajectory	action-observation 시퀀스
장기 메모리 (Long-term)	과거 시도들의 self-reflection 결과	실패 원인 분석, 개선 방향, 교훈

장기 메모리의 장점:
– 명시적이고 해석 가능한 경험 저장
– 구체적인 행동 힌트 제공
– 다음 에피소드에서 즉시 활용 가능

4. 피드백 유연성

다양한 형태와 소스의 피드백 신호 수용 가능:

피드백 유형	예시
스칼라 값	성공/실패, 점수, 보상
자유 형식 언어	구체적인 오류 메시지, 평가 코멘트
외부 피드백	컴파일러 에러, 테스트 결과, 환경 피드백
내부 시뮬레이션	Self-generated tests, 자체 평가

---

🏗️ 아키텍처 / 방법론

시스템 구성 요소

Reflexion은 세 가지 핵심 컴포넌트로 구성:

┌─────────────────────────────────────────────────────────────┐
│                      Reflexion Framework                     │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   ┌─────────┐    action    ┌─────────────┐                  │
│   │  Actor  │ ──────────▶ │ Environment │                   │
│   │  (LLM)  │ ◀────────── │             │                   │
│   └────┬────┘  observation └──────┬──────┘                  │
│        │                          │                          │
│        │ trajectory               │ reward                   │
│        ▼                          ▼                          │
│   ┌─────────────────────────────────────┐                   │
│   │            Evaluator                 │                   │
│   │    (reward score 계산)               │                   │
│   └────────────────┬────────────────────┘                   │
│                    │ feedback                                │
│                    ▼                                         │
│   ┌─────────────────────────────────────┐                   │
│   │         Self-Reflection              │                   │
│   │    (언어적 피드백 생성)              │                   │
│   └────────────────┬────────────────────┘                   │
│                    │ reflection                              │
│                    ▼                                         │
│   ┌─────────────────────────────────────┐                   │
│   │         Long-term Memory             │                   │
│   │    (성찰 내용 저장)                  │                   │
│   └─────────────────────────────────────┘                   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

1. Actor (행동자)

• 역할: 상태 관찰을 기반으로 텍스트와 행동 생성
• 구현: Chain-of-Thought (CoT) 또는 ReAct 기반
• 입력: 환경 상태(observation) + 장기 메모리(reflections)
• 출력: 행동(action) 및 trajectory
• 특징: 메모리 컴포넌트와 결합하여 과거 경험 활용

2. Evaluator (평가자)

• 역할: Actor가 생성한 출력의 품질 점수 계산
• 입력: 생성된 trajectory (단기 메모리)
• 출력: 보상 점수 (reward score)
• 구현 방식:
  • Decision-making: 사전 정의된 휴리스틱 함수 또는 GPT 기반 이진 분류
  • Reasoning: Exact Match (EM) 기반 평가
  • Programming: 테스트 실행 결과 (pass/fail)
• 참고: 반드시 LLM일 필요 없음 – 단순 테이블 룩업도 가능

3. Self-Reflection (자기 성찰)

• 역할: Actor의 자기 개선을 돕는 언어적 강화 신호(verbal reinforcement cues) 생성
• 입력:
  • 보상 신호 (reward signal)
  • 현재 trajectory
  • 장기 메모리 (persistent memory)
• 출력: 구체적이고 관련성 있는 피드백 (self-reflection)
• 구현: LLM을 통해 구현
• 핵심 기능: 환경으로부터의 피드백을 언어적 형태로 변환하여 메모리에 저장

학습 루프 (Learning Loop)

Trial 1: Task 시도 → 실패 → 성찰 생성 → 메모리 저장
    ↓
Trial 2: 메모리 참조 → Task 재시도 → 실패 → 성찰 추가
    ↓
Trial 3: 축적된 메모리 참조 → Task 재시도 → 성공!

알고리즘 핵심 단계:
1. Define: 태스크 정의
2. Generate: Actor가 trajectory 생성
3. Evaluate: Evaluator가 결과 평가
4. Reflect: 실패 시 Self-Reflection 수행
5. Update: 성찰 내용을 장기 메모리에 저장
6. Iterate: 다음 trajectory 생성 (메모리 참조)

태스크별 구현 세부사항

Decision-Making (AlfWorld)

# ReAct + Reflexion for AlfWorld
def reflexion_decision_making(task, env, max_trials=12):
    memory = []

    for trial in range(max_trials):
        # Actor: ReAct-style reasoning and acting
        trajectory = react_agent.run(task, env, memory)

        # Evaluator: Heuristic or GPT-based binary classification
        success, feedback = evaluate_trajectory(trajectory)

        if success:
            return trajectory

        # Self-Reflection: Generate verbal feedback
        reflection = generate_reflection(
            trajectory=trajectory,
            feedback=feedback,
            memory=memory
        )

        memory.append(reflection)
        env.reset()

    return None

AlfWorld에서 장기 메모리가 도움이 되는 두 가지 경우:
1. 긴 trajectory 초반의 실수를 식별하고 새로운 행동 선택이나 장기 계획을 제안
2. 검색해야 할 표면/컨테이너가 너무 많을 때, 여러 시도에 걸쳐 방을 체계적으로 탐색

Programming (HumanEval)

# Reflexion for Code Generation
def reflexion_code_generation(problem, tests, max_trials=10):
    memory = []

    for trial in range(max_trials):
        # Actor: Generate code with memory context
        code = generate_code(problem, memory)

        # Self-Generated Tests (internal feedback)
        internal_tests = generate_tests(problem, code)

        # Evaluator: Run tests
        test_results = run_tests(code, tests + internal_tests)

        if all_tests_pass(test_results):
            return code

        # Self-Reflection
        reflection = reflect_on_code(
            code=code,
            test_results=test_results,
            memory=memory
        )

        memory.append(reflection)

    return best_code

Reasoning (HotPotQA)

# Reflexion for Multi-hop QA
def reflexion_reasoning(question, context, max_trials=5):
    memory = []

    for trial in range(max_trials):
        # Actor: CoT reasoning with memory
        answer, reasoning_chain = cot_reason(
            question, context, memory
        )

        # Evaluator: Check answer correctness
        is_correct, ground_truth = evaluate_answer(answer)

        if is_correct:
            return answer

        # Self-Reflection
        reflection = reflect_on_reasoning(
            question=question,
            reasoning=reasoning_chain,
            answer=answer,
            memory=memory
        )

        memory.append(reflection)

    return best_answer

---

📊 실험 및 결과

실험 환경

태스크 유형	벤치마크	설명
Sequential Decision-Making	AlfWorld	134개 텍스트 기반 환경, 6가지 태스크 유형
Reasoning	HotPotQA	100개 다중 홉 추론 질문 (distractor 설정)
Programming	HumanEval	164개 Python 프로그래밍 문제
Programming	LeetcodeHardGym	40개 Hard 레벨 문제, 19개 언어 (새로 제안)

주요 결과

1. AlfWorld (Decision-Making)

방법	성공률
ReAct (baseline)	73%
ReAct + Reflexion (Heuristic)	97% (130/134)
ReAct + Reflexion (GPT)	97% (130/134)

• 절대적 성능 향상: +22% (12 iterative steps 내)
• 134개 태스크 중 단 4개만 실패

2. HotPotQA (Reasoning)

방법	정확도
GPT-4 (baseline)	34%
CoT + Episodic Memory	36%
GPT-4 + Reflexion	54%

• 절대적 성능 향상: +20%
• 검색, 정보 추출, 추론 능력 모두 향상

3. HumanEval (Code Generation)

방법	Pass@1
GPT-4 (baseline)	67.0%
CodeT (previous SOTA)	65.8%
GPT-4 + Reflexion	91.0%

• 절대적 성능 향상: +24% (GPT-4 대비)
• 당시 SOTA 달성 (이전 기록인 GPT-4의 80% 초과)

학습 곡선 분석

Performance vs Trial Number (AlfWorld)
───────────────────────────────────────
Trial 1:  ████████████░░░░░░░░  60%
Trial 3:  ██████████████████░░  90%
Trial 6:  ███████████████████░  95%
Trial 12: ████████████████████  97%

ReAct (no reflection): plateaus at ~75%
Reflexion: continues to improve with more trials

핵심 발견: ReAct는 일정 수준에서 성능이 정체되지만, Reflexion은 시도 횟수가 증가함에 따라 지속적으로 성능이 향상됨

Ablation Study 결과

Self-Reflection의 효과

• 에피소딕 메모리 학습 대비 8% 절대적 성능 향상
• refinement-only 접근법보다 self-reflection 기반 refinement가 더 효과적임을 입증

컴포넌트별 기여도 (HumanEval)

구성 요소	Pass@1
Base (no reflection)	67.0%
+ Self-generated tests only	77.0%
+ Self-reflection only	80.0%
+ Both (full Reflexion)	91.0%

• Self-generated tests와 self-reflection 모두 중요
• 두 요소의 시너지 효과 확인

---

💪 강점 및 기여

기술적 강점

1. 경량성 (Lightweight)
   • 가중치 업데이트 불필요: Fine-tuning 없이 in-context learning만으로 성능 향상
   • 계산 효율성: 추가 학습 비용 최소화
   • 빠른 적응: 몇 번의 시도만으로 개선
2. 해석 가능성 (Interpretability)
   • 언어적 피드백: 왜 실패했는지 자연어로 설명
   • 투명한 학습 과정: 성찰 내용을 직접 확인 가능
   • 디버깅 용이: 에이전트의 사고 과정 추적
3. 유연성 (Flexibility)
   • 다양한 피드백 소스: 외부/내부, 스칼라/언어
   • 태스크 범용성: 의사결정, 코딩, 추론 모두 적용
   • 기존 기법과 결합: CoT, ReAct와 쉽게 통합
4. 기존 방법 대비 장점
   • 전통적 RL보다 세밀한 피드백 가능 (타겟팅된 행동 변경)
   • 명시적이고 해석 가능한 에피소딕 메모리
   • 다음 에피소드에서 명확한 행동 힌트 제공

학술적 기여

1. 새로운 패러다임 제시: “Verbal RL” – 정책을 (메모리 인코딩, LLM 파라미터)로 파라미터화
2. SOTA 달성: HumanEval에서 당시 최고 성능 기록
3. 벤치마크 공개: LeetcodeHardGym 환경 공개 (40개 hard-level 문제, 19개 언어)
4. 오픈소스: 코드, 데모, 데이터셋 모두 공개

---

⚠️ 한계점 및 향후 연구

논문에서 언급한 한계

1. Local Minima 문제

• Reflexion은 본질적으로 자연어를 사용한 정책 최적화 기법
• 정책 최적화는 강력하지만 비최적 국소 최솟값(non-optimal local minima)에 빠질 수 있음

2. 메모리 용량 제한

• 슬라이딩 윈도우 방식으로 장기 메모리 용량 제한
• LLM 컨텍스트 길이 제약으로 인한 정보 손실 가능
• 저자들은 향후 연구에서 벡터 임베딩 DB나 SQL DB로 확장 권장

3. Self-Evaluation 의존성

• LLM의 자기 평가 능력에 크게 의존
• 평가 모델이 부정확하면 잘못된 방향으로 학습
• 전통적 RL과 달리 성공에 대한 형식적 보장 없음

4. Self-Reflection 품질 변동

• LLM이 생성하는 피드백의 정확성과 실행 가능성이 항상 보장되지 않음
• 핵심 이슈를 놓치거나 충분히 정확하지 않은 피드백 생성 위험

5. 코드 생성 특화 한계

• 비결정적 함수: 출력이 매번 달라지는 함수 평가 어려움
• 하드웨어 의존적 함수: 환경에 따라 출력이 달라지는 경우
• Test-driven development의 정확한 입출력 매핑 한계

향후 연구 방향

1. 고급 메모리 구조: 벡터 임베딩 데이터베이스, SQL DB, 구조화된 지식 그래프
2. Meta-Policy Reflexion: 태스크 특화 성찰을 재사용 가능한 규칙으로 통합
3. LLM 능력 향상 활용: 모델 발전에 따른 Reflexion 효과 증대 기대
4. 하이브리드 학습: 전통적 RL과의 결합을 통한 시너지

---

🔗 관련 논문

선행 연구

논문	연도	관계
ReAct: Synergizing Reasoning and Acting	2022	Actor 모델의 기반, 추론과 행동 인터리빙
Chain-of-Thought Prompting	2022	단계별 추론 기법, Actor 모델로 사용
Self-Consistency	2022	다양한 추론 경로 샘플링 후 일관된 답변 선택
Self-Refine	2023	유사한 반복적 자기 개선 접근

후속/발전 연구

논문	관계
LATS (Language Agent Tree Search)	Reflexion + Monte-Carlo Tree Search 결합
Tree of Thoughts	다중 추론 경로를 동시에 고려
Meta-Policy Reflexion (MPR)	재사용 가능한 규칙으로 성찰 통합
MAR (Multi-Agent Reflexion)	다중 에이전트 환경으로 확장

관련 프레임워크

• LangChain/LangGraph: Reflexion 패턴 구현 지원 (튜토리얼 제공)
• AutoGen: 멀티 에이전트 reflexion 구현
• Swarms: ReflexionAgent 클래스 제공

---

💻 실무 적용 포인트

Self-Reflection 프롬프트 예시

일반적인 자기 성찰 프롬프트

You are an advanced reasoning agent that can improve based on
self-reflection. You will be given a previous reasoning trial
in which you were given access to relevant context and a
question to answer. You were unsuccessful in answering the
question either because you guessed the wrong answer with a
probability above the given threshold, or you used up your
set number of reasoning steps.

In a few sentences, diagnose a possible reason for failure and
devise a new, concise, high-level plan that aims to mitigate
the same failure. Use complete sentences.

Previous Trial:
{previous_trial}

Reflection:

상세 자기 성찰 프롬프트 (실무용)

You are an expert in {topic}. You have incorrectly answered the
following multiple-choice question. Your task is to reflect on
the problem, your solution, and the correct answer.

**Question**: {question}
**Your Answer**: {agent_answer}
**Correct Answer**: {correct_answer}

Please provide:
1. **Why you failed**: Explain why your answer was incorrect
2. **Error keywords**: List keywords describing your error (general → specific)
3. **Corrected solution**: Solve the problem step-by-step based on the correct answer
4. **Future instructions**: Create detailed instructions to avoid this error
5. **General advice**: List advice for similar problems

Be concise but capture all essential information.

코드 생성용 자기 성찰 프롬프트

You are a Python programming assistant. Your previous code failed the test cases.

**Task**: {task_description}
**Your Code**:
```python
{failed_code}
</code></pre>

<strong>Error Message</strong>: {error_message}
<strong>Failed Test Cases</strong>: {failed_tests}

Reflect on your mistake and provide:
1. Root cause of the failure
2. What edge cases you missed
3. Specific changes needed to fix the code
4. Lessons for future similar tasks

<pre><code><br />### 구현 패턴 (LangGraph)

```python
from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from typing import TypedDict, List

# State definition
class ReflexionState(TypedDict):
    task: str
    trajectory: List[str]
    reflections: List[str]
    trial: int
    max_trials: int
    success: bool

# Nodes
def actor_node(state: ReflexionState) -> ReflexionState:
    """Generate trajectory using LLM with memory context"""
    llm = ChatAnthropic(model="claude-sonnet-4-20250514")

    prompt = f"""
    Task: {state['task']}
    Previous reflections: {state['reflections']}

    Generate a solution:
    """

    response = llm.invoke(prompt)
    state['trajectory'].append(response.content)
    return state

def evaluator_node(state: ReflexionState) -> ReflexionState:
    """Evaluate the trajectory"""
    state['success'] = evaluate(state['trajectory'][-1])
    return state

def reflection_node(state: ReflexionState) -> ReflexionState:
    """Generate self-reflection"""
    llm = ChatAnthropic(model="claude-sonnet-4-20250514")

    prompt = f"""
    Failed attempt: {state['trajectory'][-1]}

    What went wrong and how to improve?
    """

    reflection = llm.invoke(prompt).content
    state['reflections'].append(reflection)
    state['trial'] += 1
    return state

def should_continue(state: ReflexionState) -> str:
    if state['success']:
        return END
    if state['trial'] >= state['max_trials']:
        return END
    return "reflect"

# Build graph
workflow = StateGraph(ReflexionState)
workflow.add_node("actor", actor_node)
workflow.add_node("evaluator", evaluator_node)
workflow.add_node("reflect", reflection_node)

workflow.set_entry_point("actor")
workflow.add_edge("actor", "evaluator")
workflow.add_conditional_edges(
    "evaluator",
    should_continue,
    {"reflect": "reflect", END: END}
)
workflow.add_edge("reflect", "actor")

app = workflow.compile()

실무 적용 팁

1. 적절한 시도 횟수 설정

• 코딩 태스크: 5-10회
• 의사결정: 10-15회
• 추론: 3-5회

2. 피드백 품질 확보

• 가능하면 구체적인 외부 피드백 활용 (테스트 에러 메시지 등)
• LLM 평가 시 명확한 평가 기준 제공

3. 비용 최적화

• Self-reflection에 작은 모델 사용 고려
• 불필요한 시도 줄이기 위한 early stopping 구현

4. 적용 적합성 판단

• 적합: 복잡한 태스크, trial-and-error 가능, 명확한 피드백 신호 존재
• 부적합: 단순 태스크, 단일 시도로 충분, 피드백 모호

---

🏷️ Tags

#AIAgent #SelfReflection #VerbalRL #ReinforcementLearning #LLM #NeurIPS2023 #CodeGeneration #ReAct #ChainOfThought #EpisodicMemory #LanguageAgent #SelfImprovement #HumanEval #AlfWorld #HotPotQA #PromptEngineering #AgenticAI #TrialAndError

---

📚 참고 자료

• arXiv 논문
• NeurIPS 2023 Proceedings
• GitHub Repository
• OpenReview
• LangGraph Reflexion Tutorial
• Prompt Engineering Guide – Reflexion
• Reflecting on Reflexion (저자 블로그)