{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"openhands-opendevin","slug":"openhands-opendevin","name":"OpenHands (OpenDevin)","type":"agent","url":"https://github.com/All-Hands-AI/OpenHands","page_url":"https://unfragile.ai/openhands-opendevin","categories":["ai-agents"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"openhands-opendevin__cap_0","uri":"capability://code.generation.editing.autonomous.code.generation.with.multi.step.reasoning.and.execution","name":"autonomous code generation with multi-step reasoning and execution","description":"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.","intents":["I want an AI agent to autonomously implement a feature by writing code, running tests, and fixing failures without manual intervention","I need to generate boilerplate code and have the agent validate it works before committing","I want to delegate bug fixes to an agent that can reproduce issues, analyze stack traces, and propose solutions"],"best_for":["teams building internal tools and want to reduce code review overhead","solo developers prototyping features quickly with AI assistance","organizations evaluating AI coding agents as alternative to Devin or GitHub Copilot"],"limitations":["Agent reasoning is bounded by context window of underlying LLM — complex multi-file refactors may exceed token limits","No built-in memory of previous successful patterns across conversations — each session starts fresh","Sandbox execution adds 500ms-2s latency per action due to Docker container overhead","Agent may get stuck in infinite loops if error messages are ambiguous — requires manual intervention to reset"],"requires":["Docker daemon running locally or remote Docker socket accessible","LLM API key (OpenAI, Anthropic, or compatible provider)","Python 3.9+","Git installed in sandbox environment"],"input_types":["natural language task descriptions","code files and repository context","error messages and test output","git repository state"],"output_types":["generated code files","git commits with messages","test execution results","conversation event logs"],"categories":["code-generation-editing","planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_1","uri":"capability://automation.workflow.multi.runtime.sandboxed.execution.with.docker.kubernetes.and.remote.ssh.support","name":"multi-runtime sandboxed execution with docker, kubernetes, and remote ssh support","description":"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.","intents":["I want to execute untrusted code in an isolated environment without risking my development machine","I need to scale agent execution across multiple machines using Kubernetes","I want to run the agent against a remote server via SSH without containerization overhead"],"best_for":["enterprises requiring multi-tenant isolation and compliance (Kubernetes runtime)","developers wanting local-first execution without cloud dependencies (Docker runtime)","teams with existing SSH infrastructure who want to leverage it for agent execution"],"limitations":["Docker runtime requires daemon to be running — adds 1-2s startup per new sandbox","Kubernetes runtime requires cluster setup and image registry — higher operational complexity","Remote SSH runtime has no built-in isolation — relies on OS-level user permissions","Cross-runtime state migration not supported — agent bound to single runtime for session lifetime"],"requires":["Docker 20.10+ (for Docker runtime)","Kubernetes 1.20+ with container runtime (for K8s runtime)","SSH access with key-based auth (for remote runtime)","Python 3.9+ with openhands package installed"],"input_types":["bash commands","file paths and content","environment variables","runtime configuration (image, resource limits)"],"output_types":["command stdout/stderr","file contents","exit codes","runtime metrics (CPU, memory)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_10","uri":"capability://tool.use.integration.microagent.discovery.and.content.retrieval.for.specialized.task.handling","name":"microagent discovery and content retrieval for specialized task handling","description":"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).","intents":["I want the agent to delegate specialized tasks (e.g., database schema migration) to expert microagents","I need to extend agent capabilities without modifying core agent code","I want to compose complex workflows from specialized microagents"],"best_for":["organizations with specialized domain expertise wanting to encode it as microagents","teams building modular agent systems with pluggable components","enterprises wanting to reuse agent logic across multiple projects"],"limitations":["Microagent registry is static — requires server restart to add new microagents","No built-in versioning — microagent updates may break existing workflows","Content retrieval is synchronous — large documents may timeout","No dependency resolution — microagents can't depend on other microagents"],"requires":["Microagent implementations (Python functions or external services)","Microagent registry configuration","Network access to external content sources (optional)"],"input_types":["microagent query (task description)","task parameters","context documents"],"output_types":["microagent results","execution logs","error messages"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_11","uri":"capability://automation.workflow.docker.image.building.and.caching.with.lazy.initialization","name":"docker image building and caching with lazy initialization","description":"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.","intents":["I want to minimize sandbox startup time by reusing cached images","I need to customize the sandbox environment with additional tools or dependencies","I want to support multiple programming languages and frameworks in the sandbox"],"best_for":["teams running many agent conversations and want to minimize startup overhead","organizations with specific sandbox requirements (security tools, compliance)","developers wanting to extend sandbox capabilities with custom tools"],"limitations":["Image building is synchronous — first run takes 2-5 minutes to build image","Cache invalidation is not automatic — config changes require manual cache clearing","Image size grows with each layer — large images increase storage and pull time","Custom plugins require Docker knowledge — not accessible to non-DevOps users"],"requires":["Docker 20.10+","Sufficient disk space for image storage (2-5GB per image)","Network access to Docker registries (for base images)"],"input_types":["runtime configuration (base image, tools, dependencies)","plugin specifications","environment variables"],"output_types":["Docker image ID","image size","build duration","cache hit/miss status"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_12","uri":"capability://automation.workflow.webhook.and.batched.event.storage.for.asynchronous.persistence","name":"webhook and batched event storage for asynchronous persistence","description":"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.","intents":["I want to persist agent events asynchronously without blocking agent execution","I need to send agent events to external monitoring or logging systems","I want to optimize storage I/O by batching writes"],"best_for":["high-throughput agent deployments with many concurrent conversations","teams integrating OpenHands with external monitoring/logging systems","organizations wanting to optimize storage costs through batching"],"limitations":["Batching introduces latency — events may not be persisted immediately (up to flush interval)","In-memory buffering can lose events if process crashes before flush","Webhook delivery is not guaranteed — failed deliveries may be silently dropped","No built-in deduplication — duplicate events may be stored"],"requires":["Storage backend (file or database)","Optional: webhook endpoints for external systems","Python 3.9+"],"input_types":["agent events","webhook configuration","batch size and flush interval"],"output_types":["persisted events","webhook delivery status","batch metrics"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_13","uri":"capability://memory.knowledge.conversation.storage.with.dual.path.v0.v1.architecture.and.migration.support","name":"conversation storage with dual-path v0/v1 architecture and migration support","description":"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.","intents":["I want to store agent conversations for later review and analysis","I need to migrate from file-based to database storage without losing history","I want to query conversations by metadata (model used, execution time, etc.)"],"best_for":["teams managing large numbers of agent conversations","organizations migrating from legacy file-based storage to databases","developers building analytics on top of conversation data"],"limitations":["V0 file-based storage doesn't scale beyond single machine; requires migration for production","V1 database backend requires external database setup and maintenance","Migration from V0 to V1 may require downtime or complex dual-write logic","Conversation metadata schema may need updates as features evolve"],"requires":["openhands/storage/conversation_store.py for storage abstraction","File system (for V0) or database (for V1)","openhands/storage/data_models/* for metadata schema"],"input_types":["conversation events","metadata (model, user, timestamp)","execution results"],"output_types":["stored conversation","conversation metadata","query results"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_2","uri":"capability://tool.use.integration.llm.provider.abstraction.with.multi.model.support.and.cost.tracking","name":"llm provider abstraction with multi-model support and cost tracking","description":"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.","intents":["I want to switch between Claude, GPT-4, and open-source models without changing agent code","I need to track how much each agent conversation costs to optimize model selection","I want to use a local Ollama instance for privacy without modifying the agent"],"best_for":["teams evaluating multiple LLM providers and want to A/B test agent performance","organizations with cost constraints needing per-conversation billing","privacy-conscious teams wanting to use local models"],"limitations":["Model feature detection is static — doesn't auto-detect new capabilities if provider updates","Cost tracking is approximate — uses token estimates, not actual billing data from providers","Retry logic has fixed backoff schedule — doesn't adapt to provider-specific rate limits","No built-in prompt caching — each conversation re-sends full context to LLM"],"requires":["API key for at least one LLM provider (OpenAI, Anthropic, etc.)","Network access to LLM provider or local Ollama instance","Python 3.9+"],"input_types":["conversation messages (role, content, tool_calls)","system prompts","function/tool schemas","model configuration (temperature, max_tokens)"],"output_types":["LLM responses (text, tool calls, structured data)","token usage metrics","cost estimates","model feature flags"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_3","uri":"capability://tool.use.integration.git.provider.integration.with.multi.platform.support.and.token.management","name":"git provider integration with multi-platform support and token management","description":"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.","intents":["I want the agent to autonomously create feature branches, commit changes, and open pull requests","I need to integrate with GitHub/GitLab without hardcoding credentials in config","I want to support multiple git providers across different team repositories"],"best_for":["teams with CI/CD pipelines that want agent-generated PRs to trigger automated testing","organizations using multiple git platforms (GitHub for public, GitLab for private)","developers wanting to delegate git workflow management to the agent"],"limitations":["Secrets store is file-based — not suitable for multi-user deployments without external secret management","OAuth token refresh is manual — expired tokens require re-authentication","PR creation doesn't validate branch protection rules — may fail if branch requires reviews","No built-in support for SSH keys — only HTTPS with token auth"],"requires":["Git installed in sandbox environment","OAuth token or personal access token for git provider","Network access to git provider API","Git repository already cloned or accessible via HTTPS"],"input_types":["repository URL","branch names","commit messages","PR title and description","git provider credentials"],"output_types":["git commit hashes","branch names","pull request URLs","git operation status"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_4","uri":"capability://memory.knowledge.event.driven.conversation.management.with.persistence.and.replay","name":"event-driven conversation management with persistence and replay","description":"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.","intents":["I want to replay an agent conversation to understand why it made a particular decision","I need to persist conversation history for audit and compliance purposes","I want to resume an interrupted agent session from the last successful action"],"best_for":["teams with compliance requirements needing full audit trails","developers debugging agent behavior by replaying conversations","organizations wanting to analyze agent decision patterns"],"limitations":["File-based storage doesn't scale to thousands of conversations — requires database backend","Event replay is read-only — can't modify past events for correction","Conversation resumption requires manual intervention — no automatic recovery from failures","Event storage grows unbounded — no built-in retention policies or archival"],"requires":["File system or database for conversation storage","Python 3.9+","Sufficient disk space for event logs"],"input_types":["agent actions (code edits, command execution)","LLM messages and responses","user feedback and corrections","conversation metadata"],"output_types":["conversation event logs","conversation metadata","replay traces","conversation status"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_5","uri":"capability://automation.workflow.web.ui.with.real.time.agent.progress.visualization.and.settings.management","name":"web ui with real-time agent progress visualization and settings management","description":"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.","intents":["I want to watch the agent work in real-time and see what it's thinking","I need a UI to configure LLM providers and credentials without touching config files","I want to manage multiple agent conversations and view their history"],"best_for":["non-technical users who want to interact with the agent without CLI","teams wanting to demo agent capabilities to stakeholders","developers debugging agent behavior with visual feedback"],"limitations":["WebSocket streaming adds latency — real-time updates lag behind actual execution by 100-500ms","UI state is not persisted — refreshing the page loses current conversation context","Settings UI doesn't validate configuration before saving — invalid configs only fail at runtime","No built-in user authentication — requires external reverse proxy for multi-user deployments"],"requires":["Node.js 18+ (for frontend development)","Python 3.9+ (for backend)","Modern web browser (Chrome, Firefox, Safari, Edge)","Network access to FastAPI backend"],"input_types":["natural language task descriptions (via text input)","configuration settings (via form inputs)","file uploads (for context)","git credentials (via secure input fields)"],"output_types":["rendered conversation history","real-time agent action logs","syntax-highlighted code","execution results and errors"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_6","uri":"capability://tool.use.integration.headless.agent.execution.with.rest.api.and.programmatic.control","name":"headless agent execution with rest api and programmatic control","description":"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.","intents":["I want to integrate OpenHands into my CI/CD pipeline to automate code generation","I need to programmatically submit tasks to the agent and wait for results","I want to build a custom UI or integrate with third-party tools via REST API"],"best_for":["CI/CD pipelines automating code generation or bug fixes","teams building custom UIs or integrations on top of OpenHands","organizations wanting to embed agent capabilities in existing applications"],"limitations":["REST API is synchronous — long-running tasks block the caller, requiring timeouts","No built-in rate limiting — can be abused if exposed without authentication","API doesn't support streaming responses — requires polling for progress updates","Error responses are inconsistent between V0 and V1 architectures"],"requires":["OpenHands server running (Python 3.9+)","Network access to FastAPI backend","HTTP client library (requests, curl, etc.)","Optional: API key for authentication"],"input_types":["JSON task descriptions","conversation IDs","message content","configuration parameters"],"output_types":["conversation metadata","agent action logs","execution results","HTTP status codes and error messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_7","uri":"capability://automation.workflow.configuration.system.with.hierarchical.loading.and.environment.variable.support","name":"configuration system with hierarchical loading and environment variable support","description":"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.","intents":["I want to configure OpenHands via environment variables for Docker/Kubernetes deployment","I need to store sensitive credentials securely without committing them to git","I want to override config settings at runtime without restarting the server"],"best_for":["DevOps teams deploying OpenHands in containerized environments","organizations with strict secrets management policies","developers wanting flexible configuration for different environments (dev, staging, prod)"],"limitations":["Config validation is minimal — invalid settings only fail at runtime","Secrets store is file-based by default — not suitable for multi-instance deployments","No config hot-reload — changes require server restart","Environment variable names are not documented — requires reading source code to discover"],"requires":["Python 3.9+","YAML or JSON config file (optional)","Environment variables (optional)","File system access for secrets store"],"input_types":["environment variables","YAML/JSON config files","runtime API calls","secrets (API keys, tokens)"],"output_types":["resolved configuration object","configuration validation errors","secrets metadata"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_8","uri":"capability://automation.workflow.bash.session.management.with.stateful.command.execution.and.output.streaming","name":"bash session management with stateful command execution and output streaming","description":"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.","intents":["I want to run a sequence of commands that depend on each other's state (e.g., cd into directory, then run tests)","I need to capture command output and exit codes for error handling","I want to stream command output in real-time to the UI"],"best_for":["agents executing complex build and test workflows","developers debugging command execution issues","teams wanting to observe agent execution in real-time"],"limitations":["Bash sessions are not isolated between commands — one command can affect subsequent commands","Interactive commands (requiring user input) are not supported — timeout after 30s","Output streaming adds latency — large outputs may be buffered","Session state is lost if sandbox container crashes — no persistence across restarts"],"requires":["Bash shell available in sandbox environment","Docker or other runtime with bash support","Network connectivity for output streaming"],"input_types":["bash commands (strings)","working directory","environment variables","timeout duration"],"output_types":["command stdout/stderr","exit codes","execution duration","error messages"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__cap_9","uri":"capability://planning.reasoning.agent.state.management.with.event.driven.updates.and.conversation.lifecycle","name":"agent state management with event-driven updates and conversation lifecycle","description":"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.","intents":["I want to track the agent's state throughout task execution for debugging","I need to handle agent failures gracefully and allow recovery","I want to decompose complex tasks into subtasks and delegate to sub-agents"],"best_for":["teams building complex agent workflows with multiple steps","developers debugging agent behavior and decision-making","organizations wanting to analyze agent performance metrics"],"limitations":["State transitions are not atomic — concurrent requests may cause race conditions","No built-in deadlock detection — agents can get stuck waiting for resources","Subtask delegation is limited — no cross-conversation state sharing","State machine is implicit — no formal state diagram or validation"],"requires":["Python 3.9+","Event storage backend (file or database)","LLM provider for agent reasoning"],"input_types":["agent actions","action outcomes","user feedback","task descriptions"],"output_types":["state transitions","event logs","conversation status","error messages"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openhands-opendevin__headline","uri":"capability://automation.workflow.ai.software.engineering.agent","name":"ai software engineering agent","description":"OpenHands is an open-source AI software engineering agent that autonomously writes code, runs tests, fixes bugs, and manages git, providing a competitive alternative to proprietary coding agents.","intents":["best AI coding agent","AI agent for automated code writing","open-source coding assistant","AI tool for bug fixing","AI software development automation"],"best_for":["developers seeking automation","teams needing code quality assurance"],"limitations":["requires Docker for execution"],"requires":["Docker environment"],"input_types":["code snippets","test cases"],"output_types":["generated code","test results"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":57,"verified":false,"data_access_risk":"high","permissions":["Docker daemon running locally or remote Docker socket accessible","LLM API key (OpenAI, Anthropic, or compatible provider)","Python 3.9+","Git installed in sandbox environment","Docker 20.10+ (for Docker runtime)","Kubernetes 1.20+ with container runtime (for K8s runtime)","SSH access with key-based auth (for remote runtime)","Python 3.9+ with openhands package installed","Microagent implementations (Python functions or external services)","Microagent registry configuration"],"failure_modes":["Agent reasoning is bounded by context window of underlying LLM — complex multi-file refactors may exceed token limits","No built-in memory of previous successful patterns across conversations — each session starts fresh","Sandbox execution adds 500ms-2s latency per action due to Docker container overhead","Agent may get stuck in infinite loops if error messages are ambiguous — requires manual intervention to reset","Docker runtime requires daemon to be running — adds 1-2s startup per new sandbox","Kubernetes runtime requires cluster setup and image registry — higher operational complexity","Remote SSH runtime has no built-in isolation — relies on OS-level user permissions","Cross-runtime state migration not supported — agent bound to single runtime for session lifetime","Microagent registry is static — requires server restart to add new microagents","No built-in versioning — microagent updates may break existing workflows","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:04.693Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=openhands-opendevin","compare_url":"https://unfragile.ai/compare?artifact=openhands-opendevin"}},"signature":"X6mpi5zKxniv0Iwrn4+7mkOc55eV7IMPGTvLRvZbimj9OHGtm3tOXfzKb0QAJUU4ThqrIOhw+2+JE65Gum5fCw==","signedAt":"2026-06-21T22:05:07.286Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/openhands-opendevin","artifact":"https://unfragile.ai/openhands-opendevin","verify":"https://unfragile.ai/api/v1/verify?slug=openhands-opendevin","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}