Reflexion Agent

Language Agents with Verbal Reinforcement Learning

中文文档 | English

Architecture • Installation • Quick Start • API Reference

A Python implementation of Reflexion, a framework that equips language agents with the ability to reflect on their failures and learn from them.

Architecture

Reflexion Architecture
│
├── ReflexionAgent (Main Agent)
│   ├── Solves tasks using solve function
│   ├── Evaluates results using evaluate function
│   └── Learns from failures via reflection
│
├── Reflector (Reflection Generator)
│   ├── Analyzes failed attempts
│   ├── Extracts key insights
│   └── Generates improvement suggestions
│
├── ReflexionMemory (Reflection Storage)
│   ├── Stores reflections by task
│   ├── Retrieves relevant reflections
│   └── Formats for prompt inclusion
│
└── Types (Data Structures)
    ├── Task - Problem to solve
    ├── Attempt - Single solution attempt
    ├── Reflection - Failure analysis
    └── EvaluationResult - Success/failure status

Core Workflow

┌─────────────────────────────────────────────────────────────────┐
│                    Reflexion Execution Loop                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Task ──▶ Solve ──▶ Evaluate ──▶ Success? ──▶ Return Answer    │
│               │            │                                     │
│               │            └── No ──▶ Reflect ──▶ Store Memory   │
│               │                                    │             │
│               └────────────────────────────────────┘             │
│                         (Retry with reflections)                 │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Installation

pip install reflexion-agent

Quick Start

from reflexion import ReflexionAgent, Task, EvaluationResult, EvaluationStatus

# Define your solve function (typically uses an LLM)
def solve_fn(task, reflections):
    context = ""
    if reflections:
        context = f"\nPrevious insights:\n{reflections[0].to_prompt()}"

    # Your LLM call here
    # response = llm.generate(f"{task.question}{context}")
    return "your_answer"

# Define your evaluation function
def evaluate_fn(task, answer):
    # Check if answer is correct
    if answer == "expected_answer":
        return EvaluationResult(status=EvaluationStatus.SUCCESS, score=1.0)
    return EvaluationResult(
        status=EvaluationStatus.FAILURE,
        score=0.0,
        feedback="Answer is incorrect"
    )

# Create and run agent
agent = ReflexionAgent(solve_fn, evaluate_fn, max_attempts=3)
result = agent.run(Task(question="What is 2+2?"))

print(f"Success: {result.success}")
print(f"Answer: {result.final_answer}")
print(f"Attempts: {result.total_attempts}")

CLI Usage

# Run a single task
reflexion run "What is the capital of France?"

# Start interactive mode
reflexion interactive

# Export trajectory
reflexion run "Solve this" --export trajectory.json

API Reference

ReflexionAgent

EvaluationStatus

• SUCCESS - Task completed correctly
• FAILURE - Task failed
• PARTIAL - Partially correct

Academic Reference

Implementation of the Reflexion paper:

Reflexion: Language Agents with Verbal Reinforcement Learning

Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik R. Narasimhan, Shunyu Yao

NeurIPS 2023

Paper: https://arxiv.org/abs/2303.11366

@inproceedings{shinn2023reflexion,
  title={Reflexion: Language Agents with Verbal Reinforcement Learning},
  author={Shinn, Noah and Cassano, Federico and Gopinath, Ashwin and Narasimhan, Karthik R and Yao, Shunyu},
  booktitle={Advances in Neural Information Processing Systems (NeurIPS)},
  year={2023}
}

License

MIT License

Made with ❤️ by AI Agent Research Team