OpenHands: Uma Plataforma Aberta para Desenvolvedores de Software com IA como Agentes Generalistas

Guia de leitura

Problema e motivação

O desenvolvimento de software é uma das interfaces mais expressivas pelas quais os seres humanos interagem com o mundo digital. Embora modelos de linguagem de grande porte (LLMs) consigam gerar trechos isolados de código, a engenharia de software do mundo real exige uma interação de longo alcance: navegar por repositórios, modificar arquiteturas de múltiplos arquivos, executar comandos bash, ler documentações por meio de navegadores web e realizar autodepuração usando o feedback de execução.

Os frameworks de agentes anteriores frequentemente sofriam com lacunas arquiteturais críticas: ausência de ambientes de execução isolados, executores de código sem estado (stateless), falta de recursos de navegação web multimodal ou ausência de ferramentas de avaliação padronizadas em domínios heterogêneos. O OpenHands (anteriormente OpenDevin) atende a essa necessidade com uma plataforma de código aberto (sob licença MIT) que oferece ambientes de execução em sandbox, Interfaces Agente-Computador (ACI) extensíveis, coordenação multiagente e benchmarking padronizado.

Ideias centrais

• Arquitetura de Fluxo de Eventos (Event Stream): Instruções do usuário, ações do agente e observações de tempo de execução são registradas cronologicamente em um fluxo de eventos que unifica a comunicação entre frontends, agentes e ambientes de execução em sandbox.
• Primitivas de Linguagem de Programação (PL): Em vez de APIs customizadas e frágeis, as interações do agente são fundamentadas em ações gerais: IPythonRunCellAction, CmdRunAction e BrowseInteractiveAction (via BrowserGym).
• AgentSkills Extensíveis: Um pacote Python modular pré-carregado no kernel do IPython fornece utilitários de alto nível (por exemplo, edição de linhas baseada em AST via edit_file, análise de PDFs e extração multimodal de imagens) sem a necessidade de reinventar pacotes existentes.
• Delegação entre Agentes: Agentes especialistas lidam com fluxos de trabalho específicos de determinado domínio (por exemplo, delegar tarefas web por meio de AgentDelegateAction para um BrowsingAgent dedicado).
• Controle de Qualidade via Testes Simulados (Mocks): Testes rotineiros de integração contínua verificam regressões de prompts, ações e a estabilidade do sandbox utilizando cache determinístico de prompt-resposta, evitando chamadas caras e em tempo real à API.

Método (com as equações principais)

O ciclo de execução do OpenHands opera em uma função de etapa discreta na qual o agente mapeia um estado do ambiente $\mathcal{S}$ para uma ação $a\in \mathcal{A}$: $$a_t=\text{Agent.step}({\mathcal{S}}_t)$$ Aqui, o estado encapsula o histórico cronológico de ações e observações anteriores: $${\mathcal{S}}_t=\{(a_0,o_0),(a_1,o_1),\dots ,(a_{t-1},o_{t-1})\}\cup {\mathcal{M}}_t$$ onde ${\mathcal{M}}_t$ rastreia metadados de estado auxiliares (custo cumulativo de LLMs, pilha de delegação multiagente ativa, parâmetros de configuração).

O espaço de ações $\mathcal{A}$ inclui:

• CmdRunAction(command): Executa comandos bash arbitrários no shell Linux de destino.
• IPythonRunCellAction(code): Executa código Python com preservação de estado em um kernel Jupyter persistente, expondo as AgentSkills.
• BrowseInteractiveAction(code): Executa primitivas do BrowserGym orientadas pelo Playwright (click(bid), fill(bid, val), goto(url), etc.).
• AgentDelegateAction(subtask, agent_name): Envia um subobjetivo para a pilha de agentes a fim de acionar um especialista.
• AgentFinishAction(): Conclui a execução.

A execução ocorre dentro de um sandbox Docker seguro em arquitetura cliente-servidor. Contêineres Docker base são estendidos com um servidor REST API do OpenHands (runtime.py), etiquetados por meio de um mecanismo de dupla etiquetagem: um hash MD5 do conteúdo (target_image_repo:target_image_hash_tag) para estrita reprodutibilidade e uma tag semântica genérica (runtime:oh_v{VERSION}_{BASE_IMAGE}_tag_{IMAGE_TAG}) para builds em cache das camadas base.

Resultados (com os números mais importantes)

O OpenHands avalia agentes generalistas em 15 benchmarks que abrangem engenharia de software, navegação web e assistência geral, sem ajuste de prompt específico por benchmark:

• SWE-Bench Lite (300 instâncias, sem dicas): O CodeActAgent v1.8 com claude-3-5-sonnet@20240620 alcança uma taxa de resolução de $26,0\%$ (custo médio de $1,10 por instância), superando o SWE-Agent ($18,0\%$) e o AutoCodeRover ($19,0\%$), aproximando-se do Aider ($26,3\%$).
• HumanEvalFix (164 instâncias): O CodeActAgent v1.5 com gpt-4o-2024-05-13 resolve $79,3\%$ em uma configuração de autodepuração zero-shot (em comparação com os $48,6\%$ do StarCoder2-15B).
• WebArena (812 instâncias): O BrowsingAgent v1.0 obtém $15,5\%$ usando claude-3-5-sonnet e $14,8\%$ com gpt-4o, enquanto o CodeActAgent v1.8 via delegação alcança $15,3\%$.
• MiniWoB++ (125 ambientes): O BrowsingAgent v1.0 em regime zero-shot com gpt-4o alcança $40,8\%$.
• Assistência Geral e Raciocínio:
  • GPQA Diamond: O CodeActAgent v1.8 + claude-3-5-sonnet pontua $52,0\%$ (ficando abaixo do baseline humano especialista em $81,2\%$, mas superando o GPT-4 few-shot CoT com $38,8\%$).
  • GAIA (Validação L1): O GPTSwarm v1.0 com gpt-4o atinge $32,1\%$ ($13,2\%$ para o AutoGPT).
  • AgentBench (subconjunto OS): O CodeActAgent v1.5 atinge $57,6\%$.
  • MINT (Matemática / Código): O CodeActAgent v1.5 alcança $77,3\%$ em matemática e $50,0\%$ em código.

Limitações e questões em aberto

• Edições de Arquivos Extensos: As primitivas de edição atuais enfrentam dificuldades ao lidar com bases de código grandes ou arquivos-fonte extensos, onde alterações nos números de linha introduzem conflitos de edição.
• Integração Multimodal: Embora habilidades auxiliares (parse_image, parse_pdf) extraiam texto ou resumos de imagens usando modelos de visão externos, o raciocínio multimodal nativo integrando terminal e navegador ainda não está totalmente unificado.
• Automação de Fluxos de Trabalho: Os fluxos de trabalho ainda dependem fortemente de system prompts elaborados manualmente e loops de orquestração de agentes, em vez de arquiteturas de grafos otimizadas automaticamente (por exemplo, GPTSwarm).