Un agente de codificación es un sistema de IA que utiliza un modelo de lenguaje grande como su núcleo de razonamiento para escribir, ejecutar e iterar sobre código de forma autónoma. A diferencia de un asistente de código que sugiere completaciones en tu editor, un agente de codificación ejecuta un bucle completo de observar-decidir-actuar: lee archivos, escribe cambios, ejecuta comandos, verifica la salida y revisa hasta que la tarea está completa.
Este artículo explica cómo funciona ese bucle —el planificador, la capa de inferencia LLM, las herramientas y el entorno de ejecución aislado— y luego muestra cómo construir uno usando la API LLM de Novita y Agent Sandbox. Si quieres la capa de herramientas empaquetadas en lugar de la capa de agente, consulta Mejores Herramientas de Codificación con IA en 2026. Si quieres la variante específica de Claude de este bucle, lee ¿Qué es un Agente de Codificación Claude?.
Si estás comparando herramientas de código abierto específicamente, consulta Agentes de Codificación de Código Abierto: Mejores Herramientas y Cómo Construir Uno.
¿Qué hace que algo sea un Agente de Codificación?
La diferencia entre un asistente de código y un agente de codificación es la ejecución. Un asistente de código genera una sugerencia y se detiene. Un agente de codificación de IA genera código, lo ejecuta, lee el resultado y continúa hasta que se cumple el objetivo, o hasta que se atasca.
Esa capacidad de ejecución tiene tres requisitos concretos:
- Acceso a herramientas — la capacidad de leer archivos, escribir archivos y ejecutar comandos de shell
- Un entorno aislado (sandbox) — algún lugar donde ejecutar código que no dañe el sistema anfitrión si algo sale mal
- Un contexto persistente — las salidas de las herramientas se retroalimentan al contexto del modelo para que pueda razonar sobre lo que sucedió
Sin los tres, tienes un chatbot que puede escribir código. Con los tres, tienes un agente.
El término “agente de código” se usa de manera flexible para abarcar desde sugerencias en línea en el IDE hasta sistemas completamente autónomos que pueden tomar una tarea vagamente especificada, averiguar qué archivos están involucrados, hacer cambios y verificar que funcionan, sin un humano en el bucle para cada paso. Cuando los desarrolladores comparan opciones de “mejor agente de código”, generalmente se refieren a esto último: sistemas que completan tareas de codificación de varios pasos de manera confiable con una mínima supervisión.
Las Cuatro Capas de un Agente de Codificación
Cada agente de codificación de IA de grado de producción tiene cuatro componentes reconocibles. Los detalles de implementación varían —diferentes frameworks, diferentes LLMs, diferentes proveedores de sandbox— pero la arquitectura es consistente.
1. El Planificador
El planificador recibe la descripción de la tarea y la divide en pasos que el agente ejecutará. Para tareas simples, esto ocurre implícitamente dentro del razonamiento del modelo. Para tareas complejas —“migrar este servicio para usar la nueva biblioteca de autenticación”— un paso de planificación explícito produce una lista numerada de tareas que el modelo recorre, actualizando el estado después de cada paso.
La planificación también determina cuándo detenerse. Un agente sin un criterio de finalización seguirá añadiendo refinamientos indefinidamente o, peor aún, se repetirá en un paso fallido. La mayoría de las implementaciones codifican la condición de éxito de la tarea en el prompt del sistema y dejan que el modelo decida cuándo está terminado.
2. La Capa de Inferencia LLM
El LLM es el núcleo de razonamiento de cualquier agente de codificación de IA. Decide qué herramienta llamar a continuación, qué argumentos pasar y cómo interpretar el resultado. Esa decisión se expresa como una llamada de herramienta estructurada —un objeto JSON con el nombre de la función y los parámetros— que el framework envía a la capa de ejecución real.
Para los agentes de código, el LLM necesita manejar contextos largos de manera confiable (los resultados de las herramientas se acumulan rápidamente), devolver llamadas de herramienta bien formadas de manera consistente (un JSON mal estructurado en el paso 6 de un flujo de trabajo de 10 pasos arruina toda la ejecución) y razonar sobre los cambios de estado a través de muchas llamadas de herramienta secuenciales.
El proveedor de inferencia es importante aquí. Necesitas una API que admita function calling en formato compatible con OpenAI, salidas estructuradas para forzar JSON válido a nivel de modelo y límites de concurrencia suficientes para cargas de trabajo de agentes que generan subtareas paralelas. La API LLM de Novita AI cubre los tres con un endpoint compatible con OpenAI, lo que significa que puedes intercambiar modelos sin reescribir la lógica de análisis de llamadas de herramienta.
3. La Capa de Herramientas
Las herramientas son la interfaz del agente con el mundo. Un agente de codificación mínimo necesita cuatro:
| Herramienta | Qué hace |
|---|---|
read_file |
Devuelve el contenido de un archivo en una ruta determinada |
write_file |
Escribe una cadena en una ruta de archivo |
run_command |
Ejecuta un comando de shell y devuelve stdout + stderr |
list_directory |
Lista archivos y directorios en una ruta |
Cada herramienta debe devolver una salida completa. Los resultados truncados o los fallos silenciosos corrompen el modelo del código base del agente y causan errores compuestos más adelante. La herramienta run_command especialmente necesita capturar tanto stdout como stderr —el agente a menudo aprende más de la salida de error que de la salida de éxito.
Algunos agentes añaden una herramienta search_files para búsqueda tipo grep en un código base, o una herramienta fetch_url para leer documentación externa. El conjunto correcto depende del dominio de la tarea. Para trabajo puro de código, las cuatro anteriores cubren la mayoría de los casos.
4. El Sandbox
El sandbox es un entorno Linux aislado completo donde los comandos del agente realmente se ejecutan. Esto es importante por dos razones.
Primero, seguridad. Los agentes generan código a partir de prompts de usuario, documentación recuperada y patrones inferidos. Incluso un agente bien intencionado puede producir código que elimine archivos, abra conexiones de red o consuma recursos ilimitados. Un sandbox mantiene cualquier daño contenido dentro de un entorno aislado.
Segundo, capacidad de estado. Un buen sandbox conserva el estado del sistema de archivos a través de las llamadas de herramienta dentro de una sesión. Si el agente crea un archivo en el paso 2, debe seguir ahí en el paso 8. Los enfoques de contenedores sin estado —donde cada comando se ejecuta en un entorno nuevo— no funcionan para tareas de codificación reales.
Novita Agent Sandbox está construido sobre microVMs Firecracker, que proporcionan un aislamiento a nivel de kernel más fuerte que los contenedores estándar. Las sesiones pueden ejecutarse hasta 24 horas, el estado del sistema de archivos persiste entre comandos y el arranque en frío es inferior a 200 ms. Es lo suficientemente rápido como para que esperar a que el sandbox se inicie no interrumpa un flujo de trabajo interactivo.
Cómo Funciona el Bucle de Ejecución
Un ejemplo concreto hace que el bucle sea más fácil de seguir. Supongamos que la tarea es: “Añadir limitación de velocidad al endpoint /login.”
-
Planificar — el modelo lee la tarea e identifica lo que necesita: encontrar la ruta de login, entender el manejador actual, añadir middleware de limitación de velocidad, verificar con una ejecución de prueba.
-
Observar — el agente llama a
list_directorypara encontrar los archivos de ruta, luegoread_fileen el manejador de login. Los contenidos del archivo se añaden al contexto del modelo. -
Decidir — el modelo razona sobre el código actual y decide qué hacer: instalar la biblioteca de limitación de velocidad, modificar el manejador, añadir una prueba.
-
Actuar — el agente llama a
run_command("pip install slowapi"), luegowrite_filecon el manejador modificado, luegorun_command("pytest tests/test_login.py"). -
Observar de nuevo — la salida de la prueba se retroalimenta al contexto. Si las pruebas fallan, el modelo lee el traceback, identifica el error y escribe un archivo corregido.
-
Completar — cuando las pruebas pasan y el modelo no tiene pasos pendientes, devuelve un resumen final.
Este bucle se ejecuta dentro de una sola sesión. La ventana de contexto es la memoria de trabajo del agente —cada lectura de archivo, cada salida de comando, cada llamada de herramienta se acumula allí. Es por esto que la longitud del contexto es tan importante para los agentes de codificación: una tarea de refactorización real puede llenar fácilmente 100K tokens para el paso 15. Mira cómo los agentes exigen a los proveedores de inferencia de manera diferente que el chat de una sola vuelta.
Construyendo un Agente de Codificación con Novita
El siguiente ejemplo conecta la API LLM de Novita y Agent Sandbox. Utiliza el SDK de Python de OpenAI apuntando al endpoint de Novita —los modelos de Novita usan la misma interfaz de function calling que la API de OpenAI, por lo que la integración no requiere análisis personalizado.
import os
import json
from openai import OpenAI
from novita_sandbox.code_interpreter import Sandbox
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
sandbox = Sandbox.create(timeout=1800)
def read_file(path: str) -> str:
try:
return sandbox.files.read(path)
except Exception as e:
return f"Error: {e}"
def write_file(path: str, content: str) -> str:
try:
sandbox.files.write(path, content)
return f"Written to {path}"
except Exception as e:
return f"Error: {e}"
def run_command(cmd: str) -> str:
try:
result = sandbox.commands.run(cmd)
return str(result)
except Exception as e:
return f"Error: {e}"
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Read the contents of a file",
"parameters": {
"type": "object",
"properties": {"path": {"type": "string"}},
"required": ["path"],
},
},
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Write content to a file",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"},
},
"required": ["path", "content"],
},
},
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Run a shell command in the sandbox and return output",
"parameters": {
"type": "object",
"properties": {"cmd": {"type": "string"}},
"required": ["cmd"],
},
},
},
]
dispatch = {
"read_file": read_file,
"write_file": write_file,
"run_command": run_command,
}
def run_agent(task: str, model: str) -> str:
messages = [
{
"role": "system",
"content": (
"You are a coding agent with access to a Linux sandbox. "
"Complete tasks by calling tools. When done, return a plain-text summary."
),
},
{"role": "user", "content": task},
]
while True:
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
tool_choice="auto",
)
msg = response.choices[0].message
messages.append(msg)
if not msg.tool_calls:
return msg.content
for call in msg.tool_calls:
fn = dispatch[call.function.name]
args = json.loads(call.function.arguments)
result = fn(**args)
messages.append(
{
"role": "tool",
"tool_call_id": call.id,
"content": result,
}
)
# Reemplaza <model-id> con un modelo de function calling de novita.ai/docs
result = run_agent(
task="Escribe un script de Python que cuente palabras en un archivo de texto y ejecútalo en una entrada de muestra",
model="<model-id>",
)
print(result)
sandbox.kill()
Algunas cosas a tener en cuenta sobre esta implementación:
- El bucle
while Truese ejecuta hasta que el modelo devuelve un mensaje sin llamadas de herramienta —esa es la señal de que el agente considera la tarea completada. - Los resultados de las herramientas se añaden a
messagescomo entradas conrole: tool. Esto es lo que construye el contexto compartido a través de los pasos. sandbox.kill()libera los recursos de cómputo. Siempre llámalo cuando la sesión termine.
Para los IDs de modelos compatibles con function calling, consulta la documentación de function calling de Novita. Para una guía más completa que incluye una interfaz de Gradio, consulta Construyendo un Agente de Codificación con Agent Sandbox de Novita.
Eligiendo el LLM Adecuado para Agentes de Código
HumanEval y SWE-bench miden la generación de código de una sola vuelta. Las cargas de trabajo de agentes son diferentes —lo que realmente rompe los agentes de código en producción son los fallos en el formato de las llamadas de herramienta. Un modelo que obtiene buenos puntajes en benchmarks pero ocasionalmente devuelve JSON mal formado en sesiones complejas de múltiples vueltas fallará de maneras que son difíciles de depurar.
Los criterios de evaluación práctica para agentes de codificación de IA:
- Fiabilidad de las llamadas de herramienta — ¿con qué consistencia devuelve el modelo llamadas de herramienta bien formadas en sesiones de más de 20 pasos?
- Retención de contexto — ¿el modelo referencia correctamente un archivo que leyó hace 40 pasos?
- Seguimiento de instrucciones — ¿el agente se mantiene en la tarea o comienza a modificar archivos no relacionados?
- Corrección del código — ¿el código generado realmente se ejecuta o requiere múltiples bucles de corrección?
Ejecutar un conjunto representativo de tareas de codificación reales y medir la tasa de finalización de tareas es más informativo que cualquier benchmark público. Elige de 20 a 30 tareas de tu propio código base, ejecútalas contra los modelos candidatos y cuenta cuántas se completan sin intervención humana.
Los costos de inferencia se acumulan rápidamente a escala de agente. Una sola sesión puede consumir entre 200K y 500K tokens en todas las vueltas. Los proveedores que ofrecen almacenamiento en caché de prompts y tarifas por token competitivas cambian significativamente la economía cuando ejecutas cientos de sesiones de agente por día.
Modelos de Código Abierto como una Ruta Rentable
Los modelos frontera de código cerrado han liderado en benchmarks de codificación, pero la brecha con los mejores modelos de código abierto se ha reducido considerablemente. Modelos como DeepSeek V3 y Qwen3 ahora se desempeñan de manera competitiva en tareas de generación de código y uso de herramientas —y debido a que se sirven a través de APIs compatibles con OpenAI, cambiarlos es un cambio de una línea en el parámetro model.
Ambos están disponibles a través de la API LLM de Novita. Obtienes el mismo endpoint, la misma interfaz de function calling y la misma integración con Agent Sandbox —sin tener que gestionar la infraestructura de GPU tú mismo. Esto es importante porque la orquestación de GPU, el batching y la ingeniería de fiabilidad no son triviales; delegarlos a una API gestionada te permite centrarte en la lógica del agente.
Por qué esto es importante para los agentes de codificación específicamente: los costos de tokens por sesión impulsan la economía de las cargas de trabajo de agentes más que las tarifas de licencia. Un equipo que ejecuta 200 sesiones de agente de codificación por día y logra tasas de finalización de tareas comparables con un modelo de código abierto puede reducir sustancialmente el gasto en inferencia sin cambiar su código de integración en absoluto.
La prueba práctica: ejecuta 50 tareas de codificación representativas con tu modelo objetivo, mide la tasa de éxito de las llamadas de herramienta y la tasa de finalización de tareas, luego compara con el costo por sesión. Los números de benchmark no responderán a esta pregunta —tu carga de trabajo real lo hará.
FAQ
¿Cuál es la diferencia entre un agente de codificación y un asistente de código?
Un asistente de código (como las sugerencias en línea de GitHub Copilot) genera completaciones y se detiene. Un agente de codificación ejecuta código, lee la salida e itera. La característica definitoria es el bucle de ejecución: leer, decidir, actuar, observar, repetir. Consulta Agente de Codificación CLI vs IDE para una comparación de cómo los diferentes factores de forma de los agentes utilizan este bucle.
¿Necesito un sandbox para construir un agente de codificación?
Sí, si el agente ejecutará código generado a partir de la entrada del usuario o de fuentes externas. Sin aislamiento, una generación de código defectuosa puede dañar el sistema de archivos del anfitrión o consumir recursos ilimitados. Incluso para casos de uso solo internos, un sandbox evita que los procesos descontrolados afecten al anfitrión. Los contenedores proporcionan un aislamiento básico; los sandboxes basados en microVM como el de Novita ofrecen una separación más fuerte a nivel de kernel para cargas de trabajo multiinquilino o sensibles a la seguridad.
¿Puede un agente de codificación funcionar sin acceso a internet?
Para la mayoría de las tareas de codificación puras, sí. La lectura/escritura de archivos y la ejecución de comandos locales cubren la mayoría de los flujos de trabajo. Restringir la salida (egress) dentro del sandbox es en realidad un buen valor predeterminado: evita que el código generado realice solicitudes externas inesperadas y simplifica tu modelo de amenazas.
¿Qué determina el mejor agente de código para una tarea determinada?
La fiabilidad de las llamadas de herramienta y la tasa de finalización de tareas en tu carga de trabajo real. Las clasificaciones de benchmarks públicos son un punto de partida para preseleccionar modelos, no una respuesta definitiva. Ejecuta tus tareas representativas, mide la tasa de finalización y ten en cuenta el costo de tokens por sesión. El mejor agente de código para una pequeña startup que realiza refactorizaciones ligeras puede ser muy diferente de la mejor opción para un equipo empresarial que realiza revisiones automatizadas de PR a gran escala.
¿Cuánto tiempo puede ejecutarse una sesión de agente de codificación?
Eso depende del proveedor de sandbox. Novita Agent Sandbox admite sesiones de hasta 24 horas con el estado del sistema de archivos conservado entre comandos, lo que cubre incluso tareas de refactorización o migración extendidas sin requerir lógica de checkpoint/restore en tu código de agente.
Artículos Recomendados
- Agentes de Codificación de Código Abierto: Mejores Herramientas y Cómo Construir Uno
- Mejores Herramientas de Codificación con IA en 2026
- Construyendo un Agente de Codificación con Agent Sandbox de Novita
- Agente de Codificación CLI vs IDE: ¿Cuál es la Opción Más Inteligente para tu Próximo Proyecto?
- ¿Qué Proveedor de Inferencia es el Adecuado para Agentes de IA?
