El prompting ReAct es un patrón en el que un modelo de lenguaje alterna entre razonar y actuar: escribe un pensamiento sobre qué hacer, realiza una acción como una búsqueda o una llamada a una herramienta, lee el resultado y solo entonces decide el siguiente paso. El nombre es la abreviatura de Reason + Act (razonar y actuar) y viene de Yao et al. 2022, "ReAct: Synergizing Reasoning and Acting in Language Models". No tiene relación con React, la biblioteca de JavaScript para crear interfaces de usuario.
La mayoría de los agentes de IA que navegan, ejecutan código o editan archivos usan alguna versión de este ciclo. Una vez que lo recorres a mano, el comportamiento de un agente se vuelve mucho más fácil de predecir y de depurar.
El ciclo Pensamiento, Acción, Observación
Un prompt ReAct le pide al modelo que escriba tres tipos de líneas.
- Pensamiento (Thought): razonamiento sobre la situación actual y la información que falta.
- Acción (Action): una llamada a una herramienta con un formato fijo, como
search[query],read_file[path]ofinish[answer]. - Observación (Observation): el resultado de esa acción. El modelo no escribe esta línea. Tu programa (o tú) ejecuta la acción y añade la salida real a la transcripción.
Luego la transcripción completa vuelve al modelo, que escribe el siguiente Pensamiento. El ciclo termina cuando el modelo elige la acción de cierre. El modelo nunca ejecuta una herramienta por sí mismo; solo la pide, y el código que lo rodea decide si atiende la petición.
Por qué razonar y actuar supera a cada cosa por separado
El artículo comparó ReAct con prompts que solo razonan (cadena de pensamiento) y prompts que solo actúan (llamadas a herramientas sin razonamiento escrito). En preguntas y respuestas y en verificación de datos con una herramienta de búsqueda en Wikipedia, el razonamiento por sí solo a menudo construía un argumento muy seguro sobre un dato que el modelo se había inventado, mientras que ReAct podía buscar el dato, y los mejores resultados en preguntas y respuestas llegaron al combinar ReAct con cadena de pensamiento, recurriendo a una cuando la otra no daba una respuesta segura. Actuar sin más tenía problemas para descomponer el objetivo y reunir lo que encontraba en una respuesta; los pensamientos escritos mantenían el plan a la vista. En dos tareas interactivas, un juego de tareas domésticas basado en texto y una tienda online simulada, ReAct con uno o dos ejemplos en el prompt rindió mejor que los sistemas entrenados con los que lo compararon los autores.
La lección general: la cadena de pensamiento ayuda a un modelo a planificar, las herramientas le dan datos, y ninguna de las dos basta para una tarea que necesita ambas cosas.
Un agente ReAct, turno a turno
El bloque de abajo es un pequeño agente de programación con dos herramientas. Cada pestaña es la misma conversación un paso después: las líneas Observation son lo que el programa pegó tras ejecutar la acción anterior. Las etiquetas Thought, Action y Observation se quedan en inglés porque son el formato que busca el código del final de la página. Lee las respuestas en orden.
Thought: No sé qué prueba falla ni cómo. Ejecutar las pruebas me mostrará la aserción exacta antes de leer código. Action: run_tests[tests/test_cart.py]
Fíjate en dos cosas. La primera acción es ejecutar las pruebas, no una suposición: el modelo reunió evidencia antes de leer el código. Y cada pensamiento se refiere a la última observación, que es justo lo que la cadena de pensamiento no puede hacer.
Prueba ReAct en una app de chat
No necesitas código para ver el ciclo. En ChatGPT, Claude o Gemini puedes ser tú la herramienta: el modelo pide una acción, tú la realizas y pegas el resultado.
Pensamiento: Un ventilador ruidoso en reposo suele significar que algo está usando la CPU en segundo plano, o que al ventilador le cuesta refrigerar (polvo, rejillas tapadas). Comprobar primero el uso de CPU separa estos dos casos.
Acción: Abre el Administrador de tareas (Ctrl+Shift+Esc en Windows) o el Monitor de Actividad (Aplicaciones > Utilidades en un Mac). Ordena los procesos por CPU, espera 30 segundos y dime los tres primeros procesos y sus porcentajes de CPU.
Las mismas instrucciones, con una función real detrás de cada acción, son un agente.
Un ciclo ReAct mínimo en Python
En código, el programa envía la transcripción, busca la línea Action en la respuesta, ejecuta la función correspondiente, añade la Observation y repite. Este esbozo usa el SDK de Python de OpenAI y el prompt de sistema del agente de programación de arriba.
import re
import subprocess
from pathlib import Path
from openai import OpenAI
client = OpenAI()
MODEL = "your-model-id" # e.g. from your provider's model list
PROJECT = Path.cwd().resolve()
READABLE = {".py", ".md", ".txt", ".toml", ".cfg"}
def inside_project(arg):
# The model chooses arg: resolve it and refuse anything outside the project.
path = (PROJECT / arg).resolve()
if not path.is_relative_to(PROJECT):
raise ValueError(f"{arg} is outside the project")
return path
def run_tests(arg):
path = inside_project(arg)
if not (path.is_file() and path.name.startswith("test_") and path.suffix == ".py"):
raise ValueError(f"{arg} is not a test file")
result = subprocess.run(["pytest", str(path), "-q"], capture_output=True, text=True)
return result.stdout[-2000:]
def read_file(arg):
path = inside_project(arg)
if not path.is_file() or path.suffix not in READABLE:
raise ValueError(f"{arg} is not a file this agent may read")
return path.read_text()[:20000]
TOOLS = {"run_tests": run_tests, "read_file": read_file}
def react(task, system_prompt, max_steps=8):
transcript = f"Task: {task}\n"
for _ in range(max_steps):
response = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": transcript},
],
temperature=0,
)
text = response.choices[0].message.content
match = re.search(r"Action: (\w+)\[(.*)\]", text)
if not match:
return text
transcript += text[: match.end()] + "\n"
tool, arg = match.groups()
if tool == "finish":
return arg
try:
observation = TOOLS[tool](arg) if tool in TOOLS else f"Unknown tool: {tool}"
except Exception as error: # a missing file becomes an observation, not a crash
observation = f"Error: {error}"
transcript += f"Observation:\n{observation}\n"
return "Stopped after max_steps without an answer."
Cuatro detalles importan. La transcripción se corta justo después de la Action, porque a veces los modelos siguen escribiendo e inventan su propia Observation. Una herramienta que falla (por ejemplo, un nombre de archivo incorrecto) se convierte en una Observation a la que el modelo puede reaccionar, en lugar de romper el ciclo. El límite de pasos detiene a un modelo que se quede dando vueltas para siempre. Y la salida de las pruebas se recorta, porque un log de pruebas enorme llenaría la ventana de contexto; decidir qué entra en esa ventana es ingeniería de contexto.
Las dos herramientas también revisan su argumento antes de hacer nada. Es el modelo quien elige ese argumento, así que los límites van en la herramienta: inside_project rechaza cualquier ruta que termine fuera de la carpeta del proyecto (incluidos los trucos con ../), run_tests solo acepta archivos test_*.py y read_file solo abre unos pocos tipos de archivo de código y texto y devuelve como máximo 20.000 caracteres, de modo que un archivo .env o una clave SSH nunca llegan a la siguiente petición. Ejecutar pytest sigue ejecutando el código de tu proyecto, así que corre un agente como este en un contenedor o en una copia desechable, nunca en una máquina que guarde secretos.
Las API actuales de OpenAI, Anthropic y Google también ofrecen llamadas a herramientas nativas: describes cada herramienta con un nombre y un esquema JSON, y el modelo devuelve una llamada estructurada en lugar de una línea Action:. El ciclo es idéntico; solo desaparece el análisis del texto.
Seguridad en un ciclo ReAct
Un agente lee texto que no escribió: páginas web, archivos, salidas de herramientas. Cualquiera de ellos puede contener instrucciones dirigidas al modelo, que es la inyección de prompts. Dale a cada herramienta el mínimo acceso que necesite (solo lectura cuando sea posible), pide a una persona que confirme cualquier cosa que borre, envíe o pague, y trata las acciones que pide el modelo como una entrada no fiable que hay que revisar, no como órdenes que se ejecutan a ciegas.
Preguntas frecuentes
¿Qué es el prompting ReAct?
ReAct (abreviatura de Reason + Act, razonar y actuar) es un patrón de prompting en el que un modelo de lenguaje escribe un breve razonamiento, luego una acción como una búsqueda o una llamada a una herramienta, y lee el resultado antes de volver a razonar. Viene de Yao et al. 2022, "ReAct: Synergizing Reasoning and Acting in Language Models". No tiene nada que ver con la biblioteca React de JavaScript.
¿Qué son Pensamiento, Acción y Observación en ReAct?
Un Pensamiento (Thought) es el razonamiento del modelo sobre qué hacer a continuación. Una Acción (Action) es una llamada a una herramienta con un formato fijo, por ejemplo search[python 3.13 release notes]. La Observación (Observation) es la salida de la herramienta, que tu programa obtiene ejecutando la acción y añade al prompt. El ciclo se repite hasta que el modelo realiza una acción de cierre con su respuesta.
¿Qué diferencia hay entre ReAct y la cadena de pensamiento?
La cadena de pensamiento razona a partir de lo que el modelo ya sabe, así que un dato erróneo al principio de la cadena sigue siendo erróneo. ReAct intercala el razonamiento con acciones que traen información real, así que el modelo puede comprobar un dato, ver fallar una prueba o leer un archivo antes de continuar. El artículo de ReAct vio que apoyar el razonamiento en resultados de búsqueda reducía los datos inventados que producía la cadena de pensamiento por sí sola.
¿Los agentes de IA siguen usando ReAct?
El ciclo, sí. La mayoría de los agentes actuales razonan, llaman a una herramienta, leen el resultado y vuelven a decidir, que es el ciclo ReAct. Lo que cambió es el formato: en lugar de extraer líneas Action: del texto, las API actuales tienen llamadas a herramientas nativas (tool calling), en las que el modelo devuelve una petición estructurada y tu código envía de vuelta el resultado.
¿Puedo usar ReAct en ChatGPT sin programar?
Sí, haciendo tú de herramienta. Pídele al modelo que responda con un Pensamiento y una Acción y que luego se detenga. Tú ejecutas la acción (buscar, abrir un archivo, ejecutar un comando), pegas el resultado como Observación y repites. Es lento, pero muestra exactamente cómo decide un agente qué hacer a continuación.
