> ## Documentation Index
> Fetch the complete documentation index at: https://docs.swarms.world/llms.txt
> Use this file to discover all available pages before exploring further.

# Reflexion Agent

> Self-reflective agent that improves through iterative acting, evaluating, and reflecting with experience memory

The `ReflexionAgent` implements the Reflexion framework to improve through self-reflection. It follows a process of acting on tasks, evaluating its performance, generating self-reflections, and using these reflections to improve future responses.

Based on the research paper: [Reflexion: Language Agents with Verbal Reinforcement Learning](https://arxiv.org/abs/2303.11366) (Shinn et al., 2023).

The agent consists of three specialized sub-agents:

* **Actor**: Generates initial responses to tasks
* **Evaluator**: Critically assesses responses against quality criteria
* **Reflector**: Generates self-reflections to improve future responses

## Parameters

| Parameter         | Type  | Default             | Description                                      |
| ----------------- | ----- | ------------------- | ------------------------------------------------ |
| `agent_name`      | `str` | `"reflexion-agent"` | Name of the agent                                |
| `system_prompt`   | `str` | `REFLEXION_PROMPT`  | System prompt for the agent                      |
| `model_name`      | `str` | `"openai/o1"`       | Model name for generating responses              |
| `max_loops`       | `int` | `3`                 | Maximum number of reflection iterations per task |
| `memory_capacity` | `int` | `100`               | Maximum capacity of long-term memory             |

## Methods

### act

Generates a response to the given task using the actor agent.

```python theme={null}
response = agent.act(task: str, relevant_memories: List[Dict[str, Any]] = None) -> str
```

### evaluate

Evaluates the quality of a response to a task. Returns an evaluation string and a score between 0 and 1.

```python theme={null}
evaluation, score = agent.evaluate(task: str, response: str) -> Tuple[str, float]
```

### reflect

Generates a self-reflection based on the task, response, and evaluation.

```python theme={null}
reflection = agent.reflect(task: str, response: str, evaluation: str) -> str
```

### refine

Refines the original response based on evaluation and reflection.

```python theme={null}
refined_response = agent.refine(task: str, original_response: str, evaluation: str, reflection: str) -> str
```

### step

Processes a single task through one iteration of the Reflexion process. Returns a dictionary containing task, response, evaluation, reflection, score, and iteration number.

```python theme={null}
result = agent.step(task: str, iteration: int = 0, previous_response: str = None) -> Dict[str, Any]
```

### run

Executes the full Reflexion process for a list of tasks.

```python theme={null}
results = agent.run(tasks: List[str], include_intermediates: bool = False) -> List[Any]
```

## Example

```python theme={null}
from swarms.agents import ReflexionAgent

agent = ReflexionAgent(
    agent_name="reflexion-agent",
    model_name="openai/o1",
    max_loops=3
)

tasks = [
    "Explain quantum computing to a beginner.",
    "Write a Python function to sort a list of dictionaries by a specific key."
]

results = agent.run(tasks)

for i, result in enumerate(results):
    print(f"\nTask {i+1}: {tasks[i]}")
    print(f"Response: {result}")
```

## Memory System

The agent includes a `ReflexionMemory` system that maintains both short-term and long-term memories of past experiences, reflections, and feedback.

* Short-term memory for recent interactions
* Long-term memory for important reflections and patterns
* Automatic memory management with capacity limits
* Relevance-based memory retrieval
* Similarity-based deduplication

## Best Practices

1. **Task Clarity**: Provide clear, specific tasks to get the best results
2. **Iteration Count**: Adjust `max_loops` based on task complexity (more complex tasks benefit from more iterations)
3. **Memory Management**: Monitor memory usage and adjust `memory_capacity` as needed
4. **Model Selection**: Choose an appropriate model based on your specific use case