OpenHands (OpenDevin)

OpenHands implements a CodeActAgent that decomposes software engineering tasks into discrete actions (code edits, test execution, git operations) through an event-driven loop. The agent uses LLM reasoning to plan multi-step workflows, executes actions in an isolated Docker sandbox, observes outcomes, and iteratively refines solutions. The architecture supports both synchronous blocking calls and asynchronous event streaming via WebSocket, with full conversation state persisted across sessions.

OpenHands abstracts execution environments through a pluggable Runtime interface with concrete implementations for Docker (local containers), Kubernetes (distributed clusters), and remote SSH (existing servers). The ActionExecutionServer handles command execution, file I/O, and bash session management within each runtime. Runtime images are built once and cached, with lazy initialization of bash sessions to minimize startup overhead. The system supports runtime plugins and extensions for custom tooling.

OpenHands implements a microagent discovery system that allows agents to discover and invoke specialized sub-agents for specific tasks (e.g., database migration, API documentation generation). The system maintains a registry of available microagents with their capabilities and input/output schemas. Agents can query the registry to find suitable microagents and invoke them with task-specific parameters. Content retrieval allows microagents to fetch context from external sources (documentation, code examples).

OpenHands builds sandbox Docker images once and caches them to minimize startup overhead. The image building strategy includes base OS, development tools, and runtime dependencies. Images are tagged with a hash of their configuration, enabling cache hits for identical configurations. Lazy initialization defers bash session creation until the first command execution, reducing cold-start latency. The system supports custom runtime plugins and extensions through image layers.

OpenHands implements a batched webhook system for asynchronous event persistence. Events are buffered in memory and flushed to storage in batches, reducing I/O overhead. The system supports configurable batch size and flush interval. Webhooks can be configured to send events to external systems (monitoring, logging, analytics). Failed webhook deliveries are retried with exponential backoff. The batching system is transparent to the agent — events are immediately available for replay.

Implements conversation persistence with dual-path architecture supporting both legacy file-based storage (V0) and modern database-ready design (V1). Conversation metadata (openhands/storage/data_models/conversation_metadata.py) tracks session information, model selection, and execution metrics. Storage abstraction (openhands/storage/conversation_store.py) enables switching backends without code changes. Migration path from V0 to V1 preserves conversation history while enabling scalability improvements.

OpenHands abstracts LLM interactions through a provider-agnostic layer supporting OpenAI, Anthropic, Ollama, and other compatible APIs. The LLM configuration system loads provider credentials from environment variables or config files, handles model feature detection (supports_vision, supports_function_calling), and implements retry logic with exponential backoff for transient failures. Cost tracking is built-in, calculating token usage and API costs per conversation. The system supports streaming responses for real-time agent feedback.

OpenHands implements a provider abstraction for GitHub, GitLab, and Gitea with unified authentication and token management. The system handles OAuth flows, stores credentials securely in a file-based secrets store, and provides MCP tools for git operations (clone, commit, push, create PR). The agent can autonomously manage git workflows including branch creation, commit authoring, and pull request submission. Multi-provider support allows teams to use different git platforms without agent code changes.

OpenHands implements a conversation system that persists all agent actions and LLM interactions as immutable events. The ConversationStore abstraction supports file-based and database backends, enabling full replay of agent reasoning and execution. Conversations are identified by unique IDs and support metadata (created_at, updated_at, status). The system maintains a dual-path architecture supporting both V0 legacy synchronous conversations and V1 async event-based conversations. WebSocket streaming allows real-time observation of agent progress.

OpenHands provides a React-based web UI that streams agent actions and LLM reasoning in real-time via WebSocket. The UI displays conversation history, agent state, and execution logs with syntax highlighting. Settings management UI allows configuration of LLM providers, sandbox parameters, and git credentials without editing config files. The frontend supports internationalization (i18n) and responsive design. FastAPI backend serves the UI and manages WebSocket connections with dependency injection for shared state.

OpenHands exposes a FastAPI REST API enabling programmatic control of agent execution without the web UI. The API supports conversation creation, message submission, and status polling. Conversations can be created via POST /conversations with task description, and progress tracked via WebSocket or polling. The system supports both synchronous blocking calls (V0 legacy) and asynchronous event-based execution (V1). Authentication is pluggable, allowing integration with existing auth systems.

OpenHands implements a hierarchical configuration system that loads settings from environment variables, config files (YAML/JSON), and runtime overrides. The Openhands Config class manages LLM provider settings, sandbox parameters, and storage backends. Configuration loading follows a priority order: environment variables > config file > defaults. The system supports secrets management through a pluggable secrets store, keeping credentials separate from config. Runtime configuration can be modified via the settings management API.

OpenHands maintains persistent bash sessions within sandbox environments, enabling stateful command execution with environment variable persistence and working directory tracking. The bash session manager handles command execution, output streaming, and exit code capture. Commands are executed sequentially within the same session, preserving shell state (aliases, functions, environment variables). Output is streamed in real-time to the agent and UI. The system supports interactive commands with timeout handling.

OpenHands implements an AgentController that manages agent state through an event-driven loop. The controller processes agent actions (code edits, command execution, git operations), observes outcomes, and updates conversation state. The system supports agent delegation and subtask handling, allowing agents to break down complex tasks. State transitions are tracked through events, enabling replay and analysis. The conversation lifecycle includes creation, execution, completion, and error states.