¿Qué son los agentes de codificación? Cómo funcionan y cómo construir uno

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 completados en tu editor, un agente de codificación ejecuta un ciclo completo de observar-decidir-actuar: lee archivos, escribe cambios, ejecuta comandos, verifica la salida y revisa hasta que la tarea está terminada.

Este artículo explica cómo funciona ese ciclo —el planificador, la capa de inferencia del LLM, las herramientas y el entorno de ejecución aislado— y luego muestra cómo construir uno usando la API LLM y el Entorno Aislado para Agentes de Novita.

¿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 alcanza el objetivo —o hasta que se queda atascado.

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 — un 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 amplia para abarcar desde sugerencias en línea en el IDE hasta sistemas totalmente autónomos que pueden tomar una tarea vagamente especificada, averiguar qué archivos están involucrados, hacer cambios y verificar que funcionen —sin un humano en el bucle para cada paso. Cuando los desarrolladores comparan opciones del “mejor agente de código”, generalmente se refieren a esto último: sistemas que completan tareas de codificación de múltiples 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 LLM, diferentes proveedores de entornos aislados— 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 —“migra 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 ejecuta, 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 ha terminado.

2. La capa de inferencia del 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 a 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 a herramientas bien formadas de manera consistente (un JSON mal estructurado en el paso 6 de un flujo de trabajo de 10 pasos rompe toda la ejecución) y razonar sobre cambios de estado a través de muchas llamadas a herramientas secuenciales.

El proveedor de inferencia es importante aquí. Necesitas una API que admita llamadas a funciones en formato compatible con OpenAI, salidas estructuradas para imponer JSON válido a nivel del 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 cambiar de modelos sin reescribir la lógica de análisis de llamadas a herramientas.

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 dada
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. Resultados truncados o fallos silenciosos corrompen el modelo del agente sobre la base de código 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 estilo grep en una base de código, o una herramienta fetch_url para leer documentación externa. El conjunto adecuado depende del dominio de la tarea. Para trabajo de código puro, las cuatro anteriores cubren la mayoría de los casos.

4. El entorno aislado

El entorno aislado 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 entorno aislado mantiene cualquier daño contenido dentro de un entorno aislado.

Segundo, estado. Un buen entorno aislado preserva el estado del sistema de archivos a través de las llamadas a herramientas 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 entorno aislado se inicie no interrumpa un flujo de trabajo interactivo.

Cómo funciona el bucle de ejecución

Un ejemplo concreto facilita el seguimiento del bucle. Supongamos que la tarea es: “Añadir limitación de velocidad al endpoint /login.”

1. 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.

2. Observar — el agente llama a list_directory para encontrar los archivos de ruta, luego read_file sobre el manejador de login. Los contenidos del archivo se añaden al contexto del modelo.

3. 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.

4. Actuar — el agente llama a run_command("pip install slowapi"), luego write_file con el manejador modificado, luego run_command("pytest tests/test_login.py").

5. 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.

6. 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 archivo leído, cada salida de comando, cada llamada a 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. Vea cómo los agentes estresan 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 el Entorno Aislado para Agentes. Utiliza el SDK de OpenAI para Python apuntado al endpoint de Novita —los modelos de Novita usan la misma interfaz de llamada a funciones 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,
                }
            )


# Replace <model-id> with a function-calling model from novita.ai/docs
result = run_agent(
    task="Write a Python script that counts words in a text file and run it on a sample input",
    model="<model-id>",
)
print(result)
sandbox.kill()

Algunas cosas a tener en cuenta sobre esta implementación:

• El bucle while True se ejecuta hasta que el modelo devuelve un mensaje sin llamadas a herramientas —esa es la señal de que el agente considera la tarea completada.
• Los resultados de las herramientas se añaden a messages como entradas con role: tool. Esto es lo que acumula el contexto compartido a través de los pasos.
• sandbox.kill() libera los recursos de cómputo. Llámalo siempre cuando la sesión termine.

Para los IDs de modelos compatibles con llamadas a funciones, consulta la documentación de llamadas a funciones de Novita. Para un tutorial más completo que incluye una interfaz de Gradio, consulta Construyendo un agente de codificación con el Entorno Aislado para Agentes 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 los agentes son diferentes —lo que realmente rompe los agentes de código en producción son los fallos en el formato de las llamadas a herramientas. Un modelo que obtiene buenos resultados en benchmarks pero que 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ácticos para agentes de codificación de IA:

• Fiabilidad de las llamadas a herramientas — ¿con qué consistencia el modelo devuelve llamadas a herramientas 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. Selecciona de 20 a 30 tareas de tu propia base de código, ejecútalas contra 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 competitivas por token cambian significativamente la economía cuando ejecutas cientos de sesiones de agentes por día.

Modelos de código abierto como un camino 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 rinden de manera competitiva en generación de código y tareas de uso de herramientas —y debido a que se sirven a través de APIs compatibles con OpenAI, cambiar 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 llamada a funciones y la misma integración con el Entorno Aislado para Agentes —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 específicamente para los agentes de codificación: los costos de tokens por sesión impulsan la economía de las cargas de trabajo de agentes más que las tarifas de licencias. Un equipo que ejecuta 200 sesiones de agentes de codificación por día y que 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 a herramientas y la tasa de finalización de tareas, luego compara con el costo por sesión. Los números de los benchmarks no responderán a esta pregunta —tu carga de trabajo real sí lo hará.

Preguntas frecuentes

¿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 completados 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 formatos de agentes utilizan este bucle.

¿Necesito un entorno aislado para construir un agente de codificación?

Sí, si el agente va a 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 entorno aislado evita que procesos descontrolados afecten al anfitrión. Los contenedores proporcionan un aislamiento básico; los entornos aislados basados en microVM como el de Novita ofrecen una separación a nivel de kernel más fuerte 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 de red dentro del entorno aislado 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 a herramientas 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 ejecuta revisiones automatizadas de PR a gran escala.

¿Cuánto tiempo puede ejecutarse una sesión de un agente de codificación?

Eso depende del proveedor del entorno aislado. Novita Agent Sandbox admite sesiones de hasta 24 horas con el estado del sistema de archivos preservado 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

• Construyendo un agente de codificación con el Entorno Aislado para Agentes 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