OpenHands (OpenDevin)

Generates code through an event-driven agent loop that decomposes tasks into discrete actions (file edits, command execution, test runs). The CodeActAgent implementation uses LLM-guided planning with real-time feedback from sandbox execution results, enabling iterative refinement. Actions are serialized as structured events and persisted for replay, allowing the agent to learn from execution outcomes and self-correct without human intervention.

Provides abstraction layer (openhands/runtime/base.py) for executing agent actions across heterogeneous compute environments: Docker containers, Kubernetes clusters, and remote machines. Runtime implementations handle environment initialization, command execution, file I/O, and resource cleanup. The ActionExecutionServer exposes a gRPC/HTTP interface for remote execution, enabling distributed agent deployments without modifying core agent logic.

Executes test suites (pytest, unittest, Jest, etc.) and parses output to extract failure information. Provides structured test results (pass/fail counts, failure messages, stack traces) enabling agents to understand what broke and why. Integrates with agent loop to trigger automatic debugging and code fixes. Supports multiple test frameworks through pluggable parsers. Test results are stored in conversation history for analysis and debugging.

Enables agents to delegate complex tasks to sub-agents through AgentDelegation pattern (openhands/controller/agent_controller.py). Parent agent decomposes task into subtasks, creates child agent instances, and monitors their execution. Results from subtasks are aggregated and fed back to parent for final synthesis. Hierarchical execution enables handling of complex multi-step problems that exceed single agent's reasoning capability. Subtask execution is tracked in conversation history for transparency.

Builds Docker images for sandbox environments with cached layers to minimize startup time. Runtime initialization (openhands/runtime/utils/runtime_init.py) installs dependencies, configures environment, and prepares sandbox for agent execution. Supports custom base images and Dockerfile templates. Image caching strategy reuses layers across multiple sandbox instances, reducing build time from minutes to seconds. Sandbox specification service (openhands/runtime/sandbox_spec.py) defines image requirements per task.

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.

Abstracts LLM communication through a provider-agnostic interface (openhands/llm/base.py) supporting OpenAI, Anthropic, Ollama, and custom providers. Implements automatic retry logic with exponential backoff, token counting for cost tracking, and model feature detection (function calling, vision, streaming). Configuration hierarchy allows per-conversation model selection and fallback chains, enabling cost optimization and model experimentation without code changes.

Integrates with GitHub, GitLab, and Gitea through a provider abstraction layer (openhands/server/git_provider_integrations) supporting OAuth authentication and token management. Enables agents to create branches, commit changes with semantic messages, open pull requests, and read repository context. MCP tools expose git operations as structured actions, allowing agents to understand repository state and make informed coding decisions based on existing code patterns and branch history.

Stores agent interactions as immutable event sequences (openhands/storage/event_storage) enabling full conversation replay and debugging. Conversation metadata (openhands/storage/data_models/conversation_metadata.py) tracks session state, model selection, and execution metrics. Dual-path storage (V0/V1 architecture) supports both legacy file-based and modern database backends, with batched webhook notifications for external system integration. Events are serialized with full context, allowing deterministic replay of agent behavior.

Frontend application (React/TypeScript) provides real-time visualization of agent execution through WebSocket connections to FastAPI backend. Displays action history, command output, file edits, and test results with syntax highlighting. Settings UI enables configuration of LLM providers, sandbox parameters, and git credentials without code changes. Internationalization system (i18n) supports multiple languages, and specialized components handle conversation management, model selection, and cost tracking visualization.

Implements multi-level configuration system (openhands/core/config/openhands_config.py) supporting YAML files, environment variables, and runtime overrides. Configuration hierarchy: defaults → config file → environment variables → runtime parameters. Covers LLM selection, sandbox parameters (Docker image, memory limits), storage backends, and authentication credentials. Secrets management (openhands/storage/secrets/file_secrets_store.py) separates sensitive data from configuration, enabling safe deployment across environments.

Backend server (openhands/server/routes/manage_conversations.py) built on FastAPI with dependency injection pattern for shared state (LLM clients, storage backends, runtime instances). Session management (openhands/server/session/agent_session.py) maintains agent state across requests, enabling multi-turn conversations. WebSocket support enables real-time communication with frontend. Authentication middleware validates user context, and middleware stack handles CORS, logging, and error handling. REST API exposes conversation lifecycle (create, list, delete) and agent control (start, stop, step).

Executes bash commands in persistent shell sessions (openhands/runtime/utils/command.py) maintaining working directory and environment state across multiple commands. Captures stdout/stderr separately, tracks exit codes, and streams output in real-time to frontend via WebSocket. Implements timeout handling, signal management, and resource cleanup. Commands are executed within sandbox environment (Docker/Kubernetes/remote), providing isolation from host system.

Implements FileEditAction for modifying code files with line-based edits, full file replacement, and create operations. Tracks file state to detect conflicts when multiple edits target overlapping regions. Supports syntax highlighting through frontend integration. Changes are staged in sandbox before commit, enabling rollback if tests fail. File operations integrate with git to track modifications and enable diff visualization.