Saltar al contenido principal

OpenHands: el agente de codificación con IA de código abierto, explicado

Resumen de OpenHands, el agente de codificación con IA open source: su arquitectura, configuración local con Ollama, una corrección práctica de un bug, seguridad y limitaciones, y comparativa con Claude Code, Cursor y GitHub Copilot.
· 15 min leer

Explora con IA

OpenHands es una plataforma open source para el desarrollo de software con IA, basada en un agente capaz de inspeccionar tu repositorio, editar archivos, ejecutar comandos y pasar test. Forma parte del giro hacia el desarrollo agentivo: le das al agente una tarea completa y este avanza paso a paso hasta terminarla o pedirte tu intervención.

En este artículo, te explico la arquitectura de OpenHands y sus funciones principales, te muestro cómo configurarlo con un modelo local y lo comparo con Claude Code, Cursor y GitHub Copilot.

¿Qué son los agentes de IA? Apúntate a nuestro itinerario de aprendizaje AI Agent Fundamentals para descubrir cómo los agentes de IA pueden transformar tu forma de trabajar.

¿Qué es OpenHands?

OpenHands es una plataforma open source para crear y ejecutar agentes de IA que trabajan con código.

El nombre abarca dos cosas. Por un lado, el proyecto: un conjunto de repositorios con un SDK, un servidor, una interfaz web y un servicio alojado. Por otro, el agente de codificación que se ejecuta sobre todo ello.

Así es como funciona:

  • SDK de agentes de software: conjunto de APIs en Python y REST para crear agentes que trabajen con código, y el motor detrás del CLI de OpenHands y OpenHands Cloud
  • Servidor de agentes: expone la ejecución del agente, las conversaciones, las herramientas y los espacios de trabajo vía APIs REST y WebSocket
  • Agent Canvas: una interfaz en el navegador para conversaciones, archivos, salida del terminal, configuración de modelos, backends y automatizaciones
  • OpenHands Cloud: el servicio gestionado para equipos que no quieren mantener su propia infraestructura de backend y sandbox

Cuando la gente dice "OpenHands", normalmente se refiere al agente. Es la parte con la que trabajaremos en este artículo.

Lo habitual es darle al agente una tarea de software, señalarle un espacio de trabajo con tu código y dejar que avance con las herramientas que tiene. Por defecto dispone de terminal, editor de archivos y gestor de tareas.

El espacio de trabajo no tiene por qué ser tu portátil. Los agentes pueden usar la máquina local o ejecutarse en espacios de trabajo efímeros, por ejemplo en Docker o Kubernetes.

OpenHands tampoco te ata a un único proveedor de modelos. Puedes usarlo con Claude, GPT o cualquier otro LLM, incluidos modelos locales. Agent Canvas incluso ejecuta agentes de terceros como Claude Code y Codex en lugar del agente por defecto de OpenHands.

En resumen, OpenHands es una plataforma de agentes abierta que puedes ejecutar en tus propios términos.

Cómo funciona OpenHands

OpenHands funciona en bucle.

Un asistente de chat recibe tu prompt y devuelve texto. El agente de OpenHands recibe una tarea, realiza una acción, examina el resultado y decide el siguiente paso.

The OpenHands agent loop

El bucle del agente de OpenHands

La idea general es esta:

  • Recibir la tarea: describes el objetivo en lenguaje natural, por ejemplo: "Arregla el informe mensual para que no una meses de años distintos"
  • Inspeccionar el repositorio: el agente lista directorios, abre archivos y busca el código relacionado con la tarea
  • Trazar un plan: divide la tarea en pasos y los registra en su gestor de tareas
  • Editar o crear archivos: modifica el código con su editor de archivos
  • Ejecutar comandos y tests: lanza la batería de tests o la app en el terminal
  • Inspeccionar los resultados: lee la salida, incluidos errores y aserciones fallidas
  • Iterar: si algo sigue fallando, vuelve atrás, ajusta el plan y lo intenta de nuevo

El bucle se detiene cuando la tarea está hecha o cuando el agente necesita algo que solo tú puedes aportar, como una credencial que falta o una decisión de requisitos.

El paso 6 diferencia a OpenHands de la competencia. Una herramienta de autocompletado nunca ve qué ocurre al ejecutar su código. OpenHands sí, de modo que puede reaccionar a un test fallido y arreglar la causa.

Funciones clave de OpenHands

El autocompletado sugiere texto; OpenHands actúa sobre tu proyecto. Así lo hace.

Edición de código

OpenHands edita archivos directamente y no se limita a uno por vez.

Imagina que una función necesita un nombre nuevo. El agente actualiza su definición, encuentra cada punto de llamada y actualiza los tests que la referencian, todo dentro de la misma tarea.

Uso de terminal y herramientas

El agente tiene su propio terminal. Puede instalar dependencias, ejecutar scripts, lanzar tests y leer la salida de cualquier comando.

También puedes conectar servidores MCP (Model Context Protocol) para darle herramientas con las que no fue diseñado de serie, como un gestor de issues o un cliente de base de datos.

Comprensión del repositorio

La mayoría de generadores de código solo ven lo que pegas en el prompt.

OpenHands abre el repositorio y lo explora. Puede leer el README, seguir imports y revisar tests existentes para entender la estructura del proyecto. Así, sus cambios encajan mejor con el código que ya hay.

Las tareas largas generan otro problema: el historial de conversación crece más de lo que cabe en el modelo. OpenHands lo gestiona con un condensador de contexto, que resume partes antiguas de la conversación para que el agente pueda seguir trabajando.

Elección de modelo

Las llamadas a modelos pasan por LiteLLM, así que puedes usar cualquier proveedor y modelo que soporte. La documentación de OpenHands recomienda modelos de las familias Claude, GPT y Gemini, además de modelos de pesos abiertos con buena puntuación en el OpenHands Index.

Si tu código no puede salir de tu máquina, puedes ejecutar un modelo local. OpenHands se conecta a servidores locales como LM Studio, Ollama, vLLM y SGLang.

Ten en cuenta que el modelo influye mucho en los resultados. Algunos modelos locales tienen dificultades para usar herramientas de forma fiable, incluso con una ventana de contexto amplia.

Ejecución autónoma de tareas

Una vez delegas una tarea, el agente recorre el bucle por su cuenta. No tienes que pegar errores en un chat ni decirle qué archivo abrir a continuación.

Agent Canvas va un paso más allá con automatizaciones. Se integran con Slack, GitHub, Linear y más, y pueden ejecutarse con una programación o en respuesta a webhooks.

Pero la autonomía no garantiza corrección. Aún tienes que revisar el diff y los resultados de los tests antes de hacer merge.

Cómo usar OpenHands

La mejor forma de entender OpenHands es darle un bug y ver qué hace.

En esta sección, ejecutaré OpenHands localmente en Docker, lo conectaré a un modelo local a través de Ollama y le pediré que arregle un bug en un pequeño proyecto de Python.

Configura OpenHands

Puedes ejecutar OpenHands de varias formas:

  • Lanzador por CLI: instálalo con uv tool install openhands --python 3.14 y arranca la interfaz gráfica con openhands serve

  • Docker: ejecuta el contenedor de la app directamente con un único comando docker run

  • Agent Canvas: el nuevo cliente en navegador que se conecta a backends locales, autogestionados, Cloud o Enterprise

  • OpenHands Cloud: la versión alojada, si prefieres no ejecutar nada tú

Usaré la vía de Docker con la GUI local. La documentación de OpenHands la lista como aplicación en navegador basada en Docker en desuso y apunta a Agent Canvas como sustituto, pero sigue documentada y es la forma más rápida de tener una GUI funcionando.

Necesitarás Docker Desktop en macOS, Linux o Windows con WSL. En macOS, abre Docker Desktop, ve a Settings > Advanced y habilita el socket de Docker por defecto.

Luego arranca la app:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8

OpenHands usa el montaje del socket de Docker para iniciar un contenedor sandbox separado, y el agente ejecuta sus comandos dentro de ese sandbox, no en tu host.

Cuando los logs indiquen que el servidor está arriba, abre http://localhost:3000 en tu navegador.

OpenHands welcome page

Página de bienvenida de OpenHands

Conecta un modelo

OpenHands no hará nada hasta que le des un modelo.

Yo uso Devstral Small 2, el modelo de 24B de Mistral diseñado para codificación agentiva. Es lo bastante ligero para correr en una sola RTX 4090 o en un Mac con 32 GB de RAM. Requiere Ollama 0.13.3 o posterior.

Arranca Ollama con una ventana de contexto mayor y descarga el modelo:

OLLAMA_CONTEXT_LENGTH=32768 OLLAMA_HOST=0.0.0.0:11434 ollama serve &
ollama pull devstral-small-2:24b

No ignores la longitud de contexto. El valor por defecto de Ollama es 4096 tokens, demasiado pequeño incluso para el system prompt de OpenHands. La documentación pide al menos 22000.

En OpenHands, abre Settings, ve a la pestaña LLM y activa Advanced. Luego configura:

  1. Custom Model: openai/devstral-small-2:latest

  2. Base URL: http://host.docker.internal:11434/v1

  3. API Key: cualquier valor de relleno, como local-llm

LLM settings for a local Ollama model

Ajustes LLM para un modelo local de Ollama

El prefijo openai/ indica a OpenHands que hable con Ollama a través de su API compatible con OpenAI. La clave API no se usa, pero el campo no puede quedar vacío.

Abre un repositorio

OpenHands no puede ver tus archivos por defecto. Tienes que montar el proyecto en el sandbox.

Para este ejemplo, crea una carpeta llamada budget-tracker/project con dos archivos. El primero suma el gasto por mes:

# budget.py
def monthly_totals(transactions):
    """Sum spending per month, keyed as 'YYYY-MM'.

    Each transaction is a (date, amount) tuple, for example ("2025-01-15", 42.0).
    """
    totals = {}
    for date, amount in transactions:
        month = date[5:7]
        totals[month] = totals.get(month, 0) + amount
    return totals

El docstring promete claves YYYY-MM, pero date[5:7] solo se queda con el mes. Enero de 2025 y enero de 2026 acabarán en el mismo grupo.

El segundo archivo contiene dos tests que detectan el bug:

# test_budget.py
from budget import monthly_totals


def test_same_month_in_different_years():
    transactions = [
        ("2025-01-10", 50.0),
        ("2025-01-20", 100.0),
        ("2026-01-12", 60.0),
    ]
    assert monthly_totals(transactions) == {"2025-01": 150.0, "2026-01": 60.0}


def test_single_month():
    transactions = [("2026-03-01", 20.0), ("2026-03-15", 5.5)]
    assert monthly_totals(transactions) == {"2026-03": 25.5}

Convierte la carpeta en un repositorio Git para ver luego qué cambia el agente:

cd budget-tracker
git init
git add .
git commit -m "Initial commit"

Si ejecutas python -m pytest ahora, ambos tests fallan:

Failing tests

Tests fallando

Para dar acceso a OpenHands, detén el contenedor y añade una línea al comando docker run:

-e SANDBOX_VOLUMES=$HOME/budget-tracker:/workspace:rw \

Así, el comando completo queda:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -e SANDBOX_VOLUMES=$HOME/Desktop/budget-tracker:/workspace:rw \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8

El formato es host_path:container_path:mode. Tu proyecto aparece en el sandbox bajo /workspace y rw permite al agente editarlo.

Monta solo el proyecto que quieras que el agente modifique. Cualquier cosa montada con permisos de escritura en /workspace podrá ser cambiada por el agente.

Asigna una tarea al agente

Inicia una conversación nueva y describe el problema como si fuera un informe de bug:

Los totales mensuales fusionan el gasto del mismo mes en años diferentes.

Encuentra la causa, arréglala y ejecuta los tests para confirmar que pasan.

Y ya. No tienes que señalar budget.py ni decir qué línea está mal.

Conversation output

Salida de la conversación

A partir de aquí entra en juego el bucle del agente. Explora /workspace, lee ambos archivos y ejecuta los tests para ver qué falla. Luego edita el código y vuelve a ejecutar los tests.

The agent running pytest in the sandbox terminal

El agente ejecutando pytest en el terminal del sandbox

Revisa los cambios

El agente dice que ha terminado. Ahora puedes ver las diferencias abriendo el editor y revisando los cambios en el código.

La corrección adecuada es una línea en budget.py:

month = date[:7]

Fixed budget.py

budget.py corregido

También puedes hacer un git diff para ver las diferencias.

Esto es lo que debes comprobar:

  • El código fuente: la corrección debe estar en budget.py

  • Los tests: asegúrate de que el agente no ha editado test_budget.py para que pasen las aserciones

  • La ejecución de tests: ejecuta tú mismo python -m pytest; no te fíes solo del resumen del agente

Arquitectura de OpenHands

OpenHands tiene seis componentes principales, y cada uno cumple una función concreta.

How the OpenHands components connect

Cómo se conectan los componentes de OpenHands

Modelo de IA

El modelo hace el razonamiento. Recibe la tarea y el historial de conversación, y responde con un mensaje o con una llamada a herramienta.

El modelo no cambia tus archivos ni ejecuta nada. Solo decide qué debería pasar después. Las llamadas pasan por LiteLLM, así que el mismo agente funciona con un proveedor alojado o con un modelo local como el Devstral del artículo.

Lógica del agente

El agente se sitúa entre el modelo y todo lo demás. Ejecuta el bucle de razonamiento-acción: pide al modelo la siguiente acción, ejecuta la herramienta y gestiona el resultado o el error.

También decide qué ve el modelo. El agente gestiona el historial con condensadores y añade habilidades y prompts a cada consulta al modelo.

Cada paso queda registrado. El agente ejecuta acciones y recibe observaciones; la conversación conserva ese historial de eventos. El modelo ve estos eventos en el siguiente turno, así que sabe qué ha ocurrido ya.

Herramientas y acciones

Las herramientas son cómo el agente afecta al exterior del modelo. El set estándar incluye un terminal, un editor de archivos y un gestor de tareas; puedes añadir más vía servidores MCP.

El modelo solicita una acción, como "ejecuta pytest" o "sustituye la línea 8 en budget.py". La herramienta la ejecuta y devuelve una observación, como la salida de los tests o el archivo actualizado.

Antes de ejecutar una acción, pasa por un control de seguridad. El analizador de seguridad evalúa cada acción primero y puede pausar al agente para tu aprobación.

Entorno de desarrollo

Las herramientas no corren en tu máquina; lo hacen dentro de un sandbox.

En la configuración con Docker, OpenHands ejecuta el servidor del agente dentro de su propio contenedor. Por eso montamos el socket de Docker: el contenedor de la app lo necesita para iniciar el sandbox.

El sandbox no tiene por qué ser local. Los agentes también pueden correr en espacios efímeros, por ejemplo en Docker o Kubernetes, y el Agent Server expone ejecución, herramientas y espacios de trabajo vía APIs REST y WebSocket. La lógica del agente no cambia según dónde se ejecute el sandbox.

Repositorio

El repositorio es sobre lo que trabaja el agente. Entra en el sandbox de dos formas: una carpeta local que montas, como en el artículo, o un repo conectado a través de las integraciones con GitHub, GitLab o Bitbucket.

Un repositorio también puede indicar al agente cómo comportarse. Un archivo AGENTS.md en la raíz se inyecta en el system prompt al iniciar la conversación. Instrucciones más concretas van en .agents/skills/, donde el agente ve primero un resumen y carga el contenido completo solo cuando lo necesita.

Aquí es donde pones reglas del proyecto que el agente no puede deducir, como "ejecuta tests con make test, no con pytest".

Revisión humana

La última parte de la arquitectura eres tú.

OpenHands admite tres políticas de confirmación: aprobar cada acción, no aprobar ninguna o aprobar solo las acciones de riesgo. La última depende del analizador de seguridad, que etiqueta cada acción como riesgo LOW, MEDIUM, HIGH o UNKNOWN. NeverConfirm es la opción por defecto, así que el agente corre sin pausas salvo que lo cambies.

El segundo control llega al final. El trabajo del agente no termina hasta que leas el diff y revises los resultados de los tests.

Flujos de trabajo con OpenHands

Te mostré cómo arreglar un bug de una línea, pero OpenHands puede con tareas mucho más grandes.

Estas tareas tienen en común que requieren más de un paso. Aquí tienes seis tipos de trabajo donde el bucle del agente encaja bien.

Corregir bugs

El bug del artículo era fácil de ver en un solo archivo. En el mundo real casi nunca es así.

Imagina que los logs de producción muestran un KeyError y el stack trace apunta a una función a tres llamadas de donde entra el dato erróneo. Pegas el stack trace en OpenHands y pides una solución.

El agente recorre la cadena de llamadas hasta el origen, escribe un test que reproduce el error y confirma que falla. Luego arregla el código y ejecuta la suite completa para comprobar que no rompe nada más.

Busca siempre la prueba de reproducción. Demuestra que el agente encontró el bug real y no solo el lugar donde se manifiesta.

Implementar funcionalidades

Añadir features suele tocar más archivos de los que crees.

Por ejemplo, un script de informes por línea de comandos necesita una flag --since para filtrar transacciones por fecha. El agente debe encontrar el parser de argumentos, añadir la flag, pasar el valor a la lógica de filtrado y actualizar la ayuda. Después, escribe tests para el nuevo comportamiento y actualiza el README.

Son cuatro o cinco archivos para una feature pequeña. El agente los controla en su gestor de tareas para no parar tras el primer paso que funcione.

Refactorizar código

Refactorizar es cambiar la estructura sin cambiar el comportamiento, y la batería de tests es cómo demuestras que no cambió.

Imagina un proyecto con un gran utils.py mezclando utilidades de fechas, cadenas y archivos. Pides a OpenHands dividirlo en tres módulos.

El agente crea los módulos, mueve las funciones y actualiza cada import en el código. Ejecuta los tests tras cada movimiento; así, si algo se rompe, sabe qué cambio lo causó.

Escritura de tests

El código sin tests es un punto de partida común para un agente, porque la tarea es clara y fácil de verificar.

Por ejemplo, un módulo de parseo de fechas no tiene pruebas. El agente lee las funciones, escribe casos de pytest para entradas normales y casos límite como cadenas vacías, años bisiestos y formatos inválidos, y los ejecuta.

Si un test nuevo falla, el agente debe decidir si el test está mal o si el código tiene un bug. Esa decisión deberías revisarla tú.

Investigar bases de código existentes

No todas las tareas requieren cambios de código.

Puedes hacer preguntas como "¿Dónde valida esta app la entrada de usuario antes de llegar a la base de datos?" El agente busca en el código, sigue llamadas entre archivos y responde con rutas y referencias de línea.

Es muy útil cuando te incorporas a un proyecto nuevo o retomas código que no tocas desde hace meses. Para trabajo de solo lectura, monta el repositorio con modo :ro en lugar de :rw para que el agente no pueda cambiar nada, ni por error.

Ejecutar y depurar aplicaciones

Algunos bugs solo aparecen cuando la aplicación está en marcha.

Por ejemplo, un endpoint de API devuelve un 500 y los tests no lo cubren. El agente arranca el servidor en su terminal, lanza una petición con curl y lee el traceback en los logs del servidor.

Luego corrige el código, reinicia el servidor y vuelve a enviar la misma petición. Si la respuesta sigue mal, el bucle continúa.

Es el mismo ciclo de editar-ejecutar-comprobar que harías tú, solo que el agente gestiona cada reinicio y cada reintento.

OpenHands frente a otros agentes de codificación con IA

OpenHands no es la única herramienta que puede recibir una tarea y completarla de forma autónoma. Claude Code, Cursor y GitHub Copilot ya ofrecen funciones de agente, pero con diferencias importantes.

OpenHands vs Claude Code

Estos dos son los más parecidos. Ambos ejecutan un bucle agentivo que lee código, edita archivos, lanza comandos y comprueba resultados.

La primera diferencia es la propiedad. Cada repositorio público de OpenHands tiene su propia licencia open source y puedes leerlo, modificarlo y autohospedarlo. Claude Code es la herramienta propietaria de Anthropic para codificación agentiva, disponible en terminal, IDE, app de escritorio y navegador.

Eso nos lleva al modelo. Claude Code gira en torno a los modelos Claude de Anthropic. OpenHands funciona con cualquier proveedor soportado por LiteLLM, incluido el montaje local con Ollama del artículo.

El flujo de trabajo diario también difiere. Claude Code nació como herramienta de terminal, y ahí sigue usándose mucho. OpenHands se apoya en su interfaz web; su CLI es completa pero se mantiene sobre todo por estabilidad.

Ambas herramientas te dejan controlar el comportamiento del agente. Claude Code lee CLAUDE.md, ajustes, hooks, skills, comandos y subagentes en el directorio .claude. OpenHands lee AGENTS.md y skills desde el repositorio, y su SDK te permite crear tus propios agentes en Python.

La autonomía se gestiona de forma distinta. Claude Code controla el uso de herramientas con modos de permiso, hooks y listas de permitidos/denegados, y puede aislar comandos. OpenHands ejecuta cada comando en un sandbox de Docker por defecto y añade políticas de confirmación por encima.

En resumen, Claude Code es la opción pulida que instalas y usas al momento, mientras que OpenHands requiere más configuración y a cambio te da más control. Además, no son excluyentes: Agent Canvas puede ejecutar Claude Code como agente en lugar del agente por defecto de OpenHands.

OpenHands vs Cursor

Cursor es un editor de código con IA. OpenHands es una plataforma de agentes. Esa es la diferencia principal, y el resto se deriva de ella.

En Cursor trabajas dentro del editor y el agente trabaja a tu lado. Ves aparecer cambios, los aceptas o rechazas y sigues tecleando. En OpenHands describes una tarea, el agente trabaja en un sandbox y tú revisas el resultado. La GUI incluye una vista de VS Code al sandbox, pero no es donde ocurre la mayor parte del trabajo.

El acceso al repositorio sigue el mismo patrón. El agente de Cursor trabaja sobre el código abierto en tu editor. OpenHands trabaja sobre lo que montes en su sandbox o conectes vía una integración con Git.

La brecha se reduce con los Cloud Agents de Cursor. Se ejecutan sin supervisión en la nube y devuelven trabajo mediante ramas y pull requests; necesitan una cuenta conectada de GitHub, GitLab, Azure DevOps o Bitbucket y un plan de pago. Es parecido a lo que hace OpenHands, pero en la infraestructura de Cursor.

La extensibilidad es donde más difieren. Cursor soporta servidores MCP y reglas de proyecto, pero el editor y el agente son productos cerrados. Con OpenHands puedes cambiar el propio agente, alojarlo donde quieras y ejecutarlo con un modelo local.

OpenHands vs GitHub Copilot

GitHub Copilot empezó como autocompletado en tu editor y desde ahí creció hasta funciones de agente. OpenHands nació ya como agente.

La gran fortaleza de Copilot es dónde vive. Funciona dentro de VS Code y los IDEs de JetBrains, y su agente en la nube trabaja directamente sobre GitHub. OpenHands no tiene ese nivel de integración con IDE.

Para tareas a nivel de repositorio, el agente en la nube de Copilot es la comparación más cercana. Le asignas una issue y trabaja en un entorno de desarrollo efímero impulsado por GitHub Actions, donde puede ejecutar tests y linters antes de hacer push. OpenHands Cloud hace algo similar cuando mencionas @openhands en un comentario de issue o pull request.

La principal diferencia es la plataforma. El agente en la nube de Copilot está disponible en todos los planes de pago de Copilot en repositorios alojados en GitHub. OpenHands funciona con GitHub, GitLab, Bitbucket o una carpeta local, y puede ejecutarse en tu propia infraestructura si así lo prefieres.

Copilot te permite elegir modelo para una tarea, pero solo entre los modelos que ofrece GitHub. OpenHands no tiene esa limitación.

Aquí tienes un resumen rápido:

 OpenHandsClaude CodeCursorGitHub Copilot
OrigenOpen sourcePropietarioPropietarioPropietario
ModelosCualquier proveedor LiteLLM, incluidos localesModelos ClaudeVarios proveedores y modelos propiosModelos ofrecidos por GitHub
Interfaz principalInterfaz web, SDKTerminal, IDE, escritorio, navegadorEditor de código con IAExtensión de IDE, GitHub
Dónde corre el agenteSandbox Docker, local o remotoTu máquina o la nube de AnthropicTu editor o la nube de CursorTu IDE o GitHub Actions
AutohospedajeSíNoSolo EnterpriseNo

OpenHands comparado con otros agentes de IA

OpenHands para equipos de ingeniería de software

Para una persona, OpenHands es una herramienta que abres cuando la necesitas. En equipo, el enfoque cambia.

La mayoría de equipos ya organizan el trabajo en torno a issues, y OpenHands Cloud se integra ahí. Funciona con GitHub, GitLab y Bitbucket, además de Slack, Jira y Linear. Puedes mencionar @openhands en una issue o en un comentario de pull request, y el agente recoge la tarea desde ahí.

Luego está el trabajo que nadie pide pero todos necesitan. Las automatizaciones de Agent Canvas se ejecutan con programación o en respuesta a webhooks. Por ejemplo, un equipo puede compartir un Agent Server para revisión de código y actualizaciones de dependencias, mientras cada persona ejecuta agentes personales en su portátil.

Las pruebas funcionan igual que en el artículo. El agente ejecuta la batería de tests en su sandbox antes de informar. Pero esa ejecución no sustituye al CI: tu pipeline sigue corriendo en cada pull request, igual que con código escrito por personas.

Otro punto son los pull requests. Cuando OpenHands Cloud trabaja con GitHub, solicita tokens de corta duración que expiran a las ocho horas, con permisos de lectura y escritura sobre contenidos, issues, pull requests y workflows. En despliegues Enterprise autogestionados, el agente usa la autorización de GitHub de la persona que lo disparó, así que cada cambio queda trazado a alguien.

Así es como debe funcionar la responsabilidad. El agente puede abrir el pull request, pero quien lo aprueba es un desarrollador. La protección de ramas y las revisiones obligatorias se aplican igual a los PR del agente que al resto.

Los entornos aislados hacen que todo esto escale. Cada tarea corre en su propio sandbox, así que dos agentes corrigiendo dos bugs no pisan los archivos del otro ni compiten por el mismo puerto.

Seguridad y sandboxing en OpenHands

Una herramienta de autocompletado siempre sugiere texto y tú decides si aceptarlo.

Un agente es distinto. Recorre tu proyecto, ejecuta comandos, instala paquetes y edita archivos por su cuenta, a menudo sin preguntar. La cuestión pasa de "¿es correcto este código?" a "¿qué ha ejecutado el agente para llegar aquí?"

Entornos de ejecución aislados

El sandbox de Docker protege tus archivos y programas del host, los recursos del host y otros contenedores y procesos. Si el agente ejecuta un comando destructivo, queda limitado al contenedor.

Hay una excepción a vigilar en local. El contenedor de la app monta el socket de Docker del host para poder iniciar sandboxes, y ese acceso implica control sobre Docker en tu máquina.

Permisos del repositorio

El sandbox solo protege lo que no montas. Los archivos y directorios montados pueden modificarse o borrarse.

Monta solo el proyecto en el que trabajas, nunca tu carpeta personal. Para tareas de solo lectura, usa modo :ro . En las integraciones con Git, da acceso al agente solo a los repositorios necesarios y nada más.

Secretos y credenciales

Si proporcionas credenciales (claves de API, tokens…), el agente puede usarlas. Y un agente que puede leer un secreto también puede imprimirlo en logs o enviarlo fuera.

No montes carpetas con archivos .env con claves de producción. Dale al agente credenciales de prueba con alcance limitado y rótalas con frecuencia.

Acceso a red

Por defecto, el agente puede acceder a internet desde el contenedor. Lo necesita para instalar paquetes, pero también puede alcanzar servicios externos.

Eso abre la puerta a inyección de prompts. Una página web o un comentario en una issue pueden incluir instrucciones que el agente siga. GitHub limita este riesgo para su propio agente en la nube con un firewall que restringe el acceso a internet por defecto; merece la pena plantear límites similares en tu despliegue de OpenHands.

Ejecución de comandos

Puedes controlar qué comandos se ejecutan sin aprobación. OpenHands admite tres políticas: aprobar todo, no aprobar nada o aprobar solo acciones de riesgo. NeverConfirm es la predeterminada.

La opción de "acciones de riesgo" tiene truco. El analizador de seguridad LLM por defecto usa el nivel de riesgo que el propio modelo asigna a sus acciones. Un modelo podría etiquetar un comando destructivo como LOW y se ejecutaría sin preguntarte. El analizador clasifica el riesgo para la capa de políticas; no bloquea nada por sí mismo, y la documentación recomienda combinarlo con aislamiento en Docker.

Revisar los cambios generados

Todo lo anterior limita lo que el agente puede hacer. Pero la fase de revisión es clave porque es donde compruebas lo que ha hecho.

Lee el diff completo, no solo los archivos que esperabas cambiar. Pon especial atención a la configuración de CI, archivos de dependencias y scripts. En OpenHands Cloud, el token de GitHub del agente incluye permisos de escritura en workflows, así que un cambio en .github/workflows puede alterar lo que corre en tu pipeline.

Limitaciones de OpenHands

El código que escribe OpenHands puede seguir teniendo bugs. Que pasen los tests solo indica que el código coincide con los tests, y el agente puede escribir ambos. Si las pruebas son débiles, el código puede pasar y aun así estar mal.

Las tareas complejas a menudo te necesitan en el bucle. Requisitos vagos o una decisión de diseño que el agente no puede tomar lo detendrán o, peor, lo desviarán.

Con un modelo alojado potente, OpenHands maneja bien tareas multiarchivo. Con un modelo local pequeño, verás fallos en llamadas a herramientas y respuestas tipo chatbot; incluso con una ventana de contexto grande, algunos modelos locales no usan las herramientas de forma fiable.

Los bucles de agente también cuestan más que el chat. Cada paso vuelve a enviar el historial al modelo, y las tareas largas toman muchos pasos. La documentación de OpenHands advierte que el agente hace muchas peticiones al LLM y recomienda límites de gasto y monitorización de uso. El condensador de contexto ayuda, pero resume pasos antiguos, así que en tareas largas se pueden perder detalles.

El acceso a herramientas añade riesgo de seguridad. Un agente con terminal y acceso a red puede causar daño real si sigue instrucciones erróneas; por eso el sandbox y tu revisión son tan importantes.

Y cada cambio sigue necesitando aprobación humana. No lo olvides.

OpenHands y el futuro de los agentes de codificación con IA

Las herramientas de codificación con IA han pasado del autocompletado al chat y de ahí a agentes que completan una tarea entera. OpenHands es uno de los proyectos que están impulsando este último paso.

La dirección es clara en todo el sector. Cursor habla de una era emergente en la que agentes autónomos en la nube asumen tareas mayores y a más largo plazo. Copilot ya toma issues desde GitHub y Linear. Claude Code funciona en el terminal, el navegador y Slack.

Las plataformas open source tienen un papel específico en este cambio. Con OpenHands puedes inspeccionar cómo funciona el agente, ejecutarlo en tu propia infraestructura y elegir el modelo. Para equipos con normas estrictas de datos, a menudo es la única forma permitida de usar agentes.

Las tareas largas también traen problemas nuevos. Un agente que trabaja una hora toma más decisiones que uno que trabaja un minuto, y cada decisión es una oportunidad de desviarse de tu intención. Mejores modelos ayudan, pero también los sandboxes, las políticas de confirmación y la revisión.

Conclusión

Lo que diferencia a OpenHands de sus competidores es el control. Puedes leer el código fuente, alojarlo en tu propia infraestructura y usarlo con cualquier modelo, incluido uno local. Herramientas comerciales más cerradas como Claude Code, Cursor y GitHub Copilot ofrecen una experiencia más pulida, pero en sus términos.

Aun así, un agente con acceso a tu terminal y a tus repositorios necesita que una persona revise su trabajo. Acuérdate siempre de leer el diff y ejecutar tú mismo los tests.

Si quieres aprender a crear tu agente desde cero, mira nuestro webinar Introduction to Creating AI Agents in Python.

Dario Radečić

Autor

Dario Radečić

Científico de Datos Senior con base en Croacia. Top Tech Writer con más de 700 artículos publicados, generando más de 10M de visitas. Autor del libro Automatización del aprendizaje automático con TPOT.

FAQs

¿Qué es OpenHands?

OpenHands es una plataforma open source para crear y ejecutar agentes de IA que trabajan con código. Su agente de codificación puede inspeccionar un repositorio, editar archivos, ejecutar comandos y pruebas, e iterar sobre los resultados hasta completar una tarea. Puedes ejecutarlo en local con Docker, mediante el SDK o en OpenHands Cloud.

¿OpenHands es gratuito?

El software de OpenHands es open source, así que puedes autohospedarlo sin pagar una licencia. Lo que sí pagas es el modelo: proveedores alojados como Anthropic u OpenAI cobran por token, y los bucles de agente consumen muchos. Si usas un modelo local con Ollama o LM Studio, el único coste es tu hardware. OpenHands Cloud es un servicio comercial aparte.

¿En qué se diferencia OpenHands de GitHub Copilot o Cursor?

Copilot y Cursor giran en torno al editor, donde la IA trabaja a tu lado mientras escribes código. OpenHands es agent-first: describes una tarea, el agente trabaja en un sandbox y tú revisas el resultado. Además, es open source, funciona con cualquier modelo que soporte LiteLLM y puede ejecutarse en tu propia infraestructura, algo que ni Copilot ni Cursor ofrecen al mismo nivel.

¿Puedo ejecutar OpenHands con un modelo local?

Sí. OpenHands se conecta a servidores locales como LM Studio, Ollama, vLLM y SGLang a través de sus APIs compatibles con OpenAI. Elige un modelo diseñado para codificación agentiva, como Devstral Small 2 o Qwen3.6-35B-A3B, y configura una ventana de contexto de al menos 22000 tokens. Los modelos generales más pequeños suelen fallar al usar herramientas y responder como un chatbot.

¿Es seguro darle a OpenHands acceso a mi código?

OpenHands ejecuta los comandos del agente dentro de un sandbox de Docker, que protege tu sistema host de la mayoría de errores. Pero cualquier cosa que montes en el sandbox puede modificarse o borrarse, y cualquier credencial que proporciones puede usarse. Por defecto, el agente no pide aprobación antes de actuar, así que monta solo el proyecto necesario, usa credenciales de prueba con alcance limitado y revisa cada diff antes de hacer merge.

Temas

Relacionado

An avian AI exits its cage

blog

12 alternativas de código abierto a GPT-4

Tutorial

Tutorial de la API de OpenAI Assistants