Programación agéntica con llamada a herramientas
En esta página
Lección actualizada el 2 de noviembre de 2026. Los ejemplos originales utilizaban Devstral, que se eliminó de la API el 31 de julio de 2026. Ahora utilizan Mistral Small 4 (
mistral-small-2603), y el bucle agéntico sigue el modelo de la documentación de Mistral (todas las llamadas a herramientas en una respuesta se procesan hasta obtener la respuesta final). Fuente: Llamada a funciones.
¿Qué es la programación agéntica?
La programación agéntica cambia la naturaleza de lo que le pides al modelo que haga. En lugar de solicitar un fragmento de código, luego otro y después un tercero para ensamblarlos tú mismo, asignas una tarea completa. El modelo la resuelve encadenando los pasos por sí mismo: exploración, planificación, implementación y verificación. Tú sigues siendo quien decide qué hay que hacer, pero dejas de microgestionar cada movimiento.
Los modelos Devstral se diseñaron para este flujo de trabajo; los modelos de propósito general actuales, liderados por Mistral Small 4, lo gestionan mediante la llamada a herramientas. Un agente no solo responde a una pregunta; actúa sobre el repositorio.
El ciclo agéntico
Fase 1: Comprender
El agente siempre empieza orientándose. Lee la estructura de carpetas y archivos, identifica los archivos relevantes para la tarea solicitada, rastrea las dependencias entre módulos para ver qué podría afectar un cambio y toma nota de las convenciones existentes: nomenclatura, organización de pruebas y patrones recurrentes. Esta fase parece improductiva porque no escribe código, pero determina si el código resultante parecerá tuyo o el de un desconocido.
Fase 2: Planificar
Antes de escribir una sola línea, el agente formula un plan. Desglosa la tarea en subtareas ordenadas, distingue los archivos que hay que modificar de los que hay que crear, anticipa efectos secundarios y riesgos de regresión, y decide un enfoque técnico. Este es el momento en que tu intervención resulta más barata: corregir un plan lleva treinta segundos; corregir diez archivos que ya has escrito lleva mucho más tiempo.
Fase 3: Ejecutar
La implementación despliega el plan paso a paso. El agente edita archivos existentes, crea nuevos cuando la estructura lo requiere, actualiza las importaciones y dependencias desplazadas por sus cambios y ajusta los archivos de configuración sobre la marcha. La coherencia en todos estos cambios es exactamente lo que un modelo de completado no puede garantizar.
Fase 4: Verificar
Finalmente llega la prueba de que el trabajo se mantiene. El agente ejecuta la suite de pruebas existente, escribe nuevas pruebas para el código que acaba de añadir, se asegura de que la compilación pasa y revisa su propio diff en busca de errores o modificaciones stray. Un agente que salta esta fase produce código plausible, no código correcto.
Ejemplo práctico: corrección de un error
Supongamos que le dices al agente: «Los usuarios reciben un error 500 cuando envían un formulario con un correo electrónico que contiene un ’+’». El ciclo toma entonces esta forma:
1. COMPRENDER
-> Buscar archivos relacionados con el formulario (buscar "email" en el código)
-> Leer el controlador que gestiona el envío
-> Leer la función de validación de correo electrónico
-> Identificar la expresión regular que rechaza '+'
2. PLANIFICAR
-> Modificar la expresión regular de validación para aceptar '+'
-> Añadir una prueba unitaria para correos con '+'
-> Verificar que ninguna otra parte del código filtre '+'
3. EJECUTAR
-> Modificar src/validators/email.py: corregir el patrón de la expresión regular
-> Crear tests/test_email_validation.py: añadir casos con '+'
-> Modificar src/controllers/form.py: añadir un registro para depuración
4. VERIFICAR
-> Ejecutar pytest -> todas las pruebas pasan
-> Comprobar diff -> los cambios son coherentes y mínimos
Observa la tercera línea del plan: el agente no solo arregla donde se manifiesta el error; comprueba que ningún otro filtro rechace el carácter en otro lugar. Esta búsqueda de la causa raíz, en lugar de solo del síntoma, es lo que distingue una corrección agéntica de un parche puntual.
Uso de herramientas en la práctica
El agente actúa sobre su entorno mediante llamadas a funciones. Declaras las herramientas disponibles en la solicitud, incluyendo su nombre, descripción y esquema de parámetros; el modelo elige cuáles llamar y con qué argumentos.
# Ejemplo de una conversación agéntica
messages = [
{
"role": "user",
"content": "Añade validación de contraseñas robustas al módulo de autenticación."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Lee el contenido de un archivo del proyecto",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Ruta del archivo"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Escribe o modifica un archivo del proyecto",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Ejecuta un comando de shell",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # valor por defecto: el modelo decide si llamar a una herramienta
)
Para esta solicitud, la secuencia típica comienza con read_file("src/auth/validators.py") para entender el código existente, continúa con read_file("tests/test_auth.py") para ver el formato de las pruebas actuales, y luego pasa a la escritura: write_file("src/auth/validators.py", ...) con la regla de validación añadida, write_file("tests/test_auth.py", ...) con los nuevos casos, y finalmente run_command("pytest tests/test_auth.py") para verificar. El orden importa: al abrir ambos archivos antes de tocar un solo carácter, el agente capta tus convenciones y las reproduce, en lugar de importar unas que haya visto en otro sitio.
Bucle agéntico de múltiples turnos
Nada de esto ocurre en una única llamada. El corazón de la programación agéntica es el bucle de múltiples turnos: el modelo propone una acción, tu código la ejecuta y le envías el resultado para que pueda decidir el siguiente paso. Tú mantienes el control de la ejecución real, lo que también sirve como tu barrera de seguridad.
import json
TOOLS = {"read_file": read_file, "write_file": write_file, "run_command": run_command}
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
for _ in range(30): # barrera de seguridad: un agente nunca debe entrar en un bucle infinito
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # no hay más llamadas a herramientas: ha llegado la respuesta final
for tool_call in tool_calls: # una respuesta puede contener múltiples llamadas
name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
result = TOOLS[name](**arguments)
messages.append({
"role": "tool",
"name": name,
"content": str(result),
"tool_call_id": tool_call.id,
})
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
print(response.choices[0].message.content)
Tres detalles son importantes. El mensaje del agente y cada resultado de herramienta se reinyectan en el historial, emparejados por el tool_call_id: si omites alguno, el agente pierde el hilo y vuelve a llamar a las mismas herramientas en bucle. Una única respuesta puede contener múltiples llamadas a herramientas, ya que las llamadas paralelas están permitidas por defecto (parallel_tool_calls=False las prohíbe): procésalas todas. Por último, limita el número de turnos y haz que un humano valide los comandos de shell y las escrituras de archivos: un agente que ejecuta todo lo que propone es un riesgo, no un ahorro de tiempo.
Puntos clave
- La programación agéntica sigue un ciclo: comprender, planificar, ejecutar, verificar
- El agente actúa sobre el repositorio mediante llamada a herramientas (
tools,tool_choice) - El bucle de múltiples turnos permite al agente iterar hasta la resolución completa
- El agente modifica múltiples archivos de forma coherente en una única tarea
- La fase de verificación (pruebas, compilación) es esencial para la fiabilidad