OpenHands

OpenHands decomposes high-level software engineering tasks into executable subtasks using an agentic loop that iteratively plans, executes, observes, and refines. The agent maintains internal state across multiple reasoning steps, using LLM-based planning to decide which tools to invoke next based on task progress and environmental feedback. This enables multi-step workflows like 'implement a feature' or 'fix a bug' to be executed without human intervention between steps.

OpenHands maintains a dynamic context window that includes relevant code files, function signatures, and dependency graphs, automatically selecting which files to include in LLM prompts based on the current task. The agent uses static analysis (AST parsing, import tracing) to identify related code and avoid context explosion while ensuring the LLM has sufficient information to make correct decisions. This context is updated after each action based on what files were modified or accessed.

OpenHands can pause execution and request human feedback when it encounters ambiguity or needs clarification. The agent can ask questions about task requirements, show proposed changes for approval, or request guidance on complex decisions. This enables a collaborative mode where the agent handles routine tasks but escalates decisions to humans.

OpenHands supports multiple programming languages (Python, JavaScript, TypeScript, Java, Go, Rust, etc.) with language-specific parsers, syntax validators, and code generation patterns. The agent can understand code structure in any supported language and generate syntactically correct code. Language detection is automatic based on file extensions and content analysis.

OpenHands can analyze code for performance issues by running profilers (cProfile for Python, Chrome DevTools for JavaScript, etc.) and interpreting results. The agent identifies bottlenecks and suggests optimizations (caching, algorithm improvements, parallelization). This enables the agent to autonomously improve code performance.

OpenHands can generate or update code documentation (docstrings, comments, README sections) based on code analysis. The agent understands function signatures, parameters, and return types, then generates documentation in standard formats (Google-style, NumPy-style, JSDoc). Documentation is kept in sync with code changes automatically.

OpenHands provides a unified interface for the agent to invoke external tools via a tool registry that includes bash command execution, file system operations, and language-specific interpreters. The agent receives structured feedback from each tool invocation (stdout, stderr, exit code, execution time) which informs subsequent decisions. Tool calls are validated against a safety policy before execution to prevent dangerous operations like `rm -rf /`.

OpenHands generates code by prompting an LLM and then validates the generated code using language-specific parsers (tree-sitter, Python AST, TypeScript compiler) before committing changes. If syntax is invalid, the agent receives detailed error messages and can iteratively refine the code. This prevents broken code from being written to disk and ensures generated code is at least syntactically correct.

OpenHands can execute test suites (pytest, Jest, unittest, etc.) and parse test output to identify failures, then use that feedback to guide code modifications. The agent understands test failure messages and can correlate them to specific code locations, enabling it to iteratively fix code until tests pass. This creates a feedback loop where the agent's changes are validated against the test suite.

OpenHands integrates with Git to track file changes, generate meaningful commit messages, and manage branches. The agent can create commits with appropriate messages based on the changes made, revert changes if needed, and maintain a clean git history. This enables the agent to work within standard version control workflows and produce auditable change records.

OpenHands can refactor code across multiple files by understanding code structure (classes, functions, imports) and updating all references consistently. The agent uses AST analysis to identify all usages of a renamed function or moved class, then updates them atomically. This prevents broken references and ensures refactoring is complete across the codebase.

OpenHands analyzes error messages, stack traces, and logs to diagnose root causes and suggest fixes. The agent can parse error output from compilers, interpreters, and test frameworks, correlate errors to code locations, and use that information to guide code modifications. This enables the agent to autonomously debug issues without human intervention.

OpenHands accepts high-level natural language task descriptions (e.g., 'add pagination to the user list endpoint') and decomposes them into concrete steps using LLM reasoning. The agent creates a plan that includes identifying affected files, understanding current implementation, making changes, and validating results. This plan is executed step-by-step with feedback loops.

OpenHands automatically manages imports and dependencies when generating or modifying code. When the agent uses a new function or class, it can add the necessary import statements, install missing packages via package managers (pip, npm, etc.), and update dependency files (requirements.txt, package.json). This ensures generated code is immediately runnable without manual dependency resolution.