OpenHands cloud 1.36.0: Fixing legacy config loads

With 78.1k stars and 9.9k forks, OpenHands dominates as the leading open-source AI coding agent, yet its cloud migration triggers critical profile loading failures.

The cloud-1.36.0 release tag fbb7a00 introduces a specific regression where legacy configurations fail to seed Default LLM profiles, breaking enterprise deployments. While Gartner forecasts that 40% of enterprise applications will embed task-specific AI agents by year-end 2026, the underlying infrastructure for these agents remains fragile during version transitions. The update authored by VascoSch92 on 28 May intended to harmonize SaaS extensions with the core repository but instead created a dependency gap for users migrating from previous iterations.

The fix already ships inside the release: commit fbb7a00 parses deprecated monolithic parameters into structured Default LLM profile objects on service restart, so the manual reconciliation that used to halt agent initialization disappears. What still breaks deployments is what the parser assumes. Legacy files that deviate from the strict schema fail silently, and Cloud API rate limiting can pause older sandboxes mid-seed, leaving an agent that never loads and a UI error that says nothing about the cause.

Defining the OpenHands Cloud Environment and Legacy Configuration

OpenHands Cloud Environment and Legacy Config Definitions

The OpenHands cloud environment is an autonomous coding agent platform with 78.1k GitHub stars. Legacy configurations represent deprecated, monolithic parameter sets that often trigger profile loading errors during migration to the cloud-1.36.0 release tag. These legacy files lack the event-sourced state model found in the modern OpenHands Software Agent SDK, forcing operators to manually reconcile immutable configuration requirements. The transition from the original OpenDevin project name in Spring 2024 to current non-profit stewardship reflects this architectural shift toward scalable cloud deployment.

Commit fbb7a00 seeds default LLM profiles from legacy configs to resolve loading errors during the cloud-1.36.0 rollout. This specific tag automates the migration of deprecated parameter sets, eliminating manual reconciliation for operators managing the OpenHands Software Agent SDK. However, the automated seed function assumes legacy files follow a strict schema; deviations cause silent failures in the event-sourced state model. Organizations must validate their monolithic parameter sets against the new immutable configuration requirements before upgrading. Pin to this tag only after verifying legacy config compatibility: an unseeded profile leaves the agent looping at initialization.

OpenHands vs Devin 2.0 Success Rates and Costs

OpenHands paired with Claude Opus 4.6 achieves a 68.4% success rate on SWE-bench Verified, versus 45.8% for Devin 2.0. This performance delta dictates adoption for enterprises prioritizing resolution reliability over brand recognition. The architectural choice to validate full execution paths yields higher completion metrics than proprietary black-box alternatives. Running self-hosted GPU cloud infrastructure limits expenditure to between $0.20 and $1.05 per resolved task. Devin 2.0 enforces a subscription-based model charging per task without exposing underlying cost controls. This creates a hard ceiling on scalability for high-volume users locked into vendor pricing. The trade-off is operational complexity against predictable marginal cost: high-frequency development cycles favor the open-weight approach, while low-volume teams may still tolerate the premium for managed services.

Mechanics of Seeding Default LLM Profiles from Legacy Configs

Legacy Config to Default LLM Profile Data Mapping

VascoSch92 tagged this release on 28 May at 13:22, marking the moment cloud-1.36.0 began parsing deprecated monolithic parameters into structured Default LLM profile objects. This transformation maps legacy keys to the new schema, resolving the loading errors that previously halted agent initialization during cloud migration. Silent failures occur if the legacy config contains malformed JSON rather than explicit error messages.

The migration process executes a rigid four-step transformation sequence:

1. Scanning the legacy configuration file for unrecognized or deprecated keys.
2. Extracting model identifiers such as Claude Opus 4.6 or GPT-4o and mapping them to the model_name field.
3. Converting raw token limits into the new context_window integer format.
4. Generating a valid JSON profile that the OpenHands Software Agent SDK can ingest without manual reconciliation.

Rate limiting behavior within the Cloud API complicates the procedure because pausing older sandboxes during migration can interrupt the profile loading sequence if concurrency limits are hit. LangChain requires explicit state definitions for branching workflows, whereas OpenHands automates this mapping but sacrifices granular control over intermediate state validation. Reduced visibility into specific parsing failures is the price of this automation. Validate generated profiles against a test suite before deploying to production clusters, and verify that the seeded profiles populate the context_window integer correctly, because incorrect mapping causes immediate runtime rejection; teams on the free individual cloud plan and enterprises running custom VPCs should inspect the generated JSON objects before scaling traffic, since ambiguous legacy keys are not flagged as errors until runtime.

Error Signatures Seen During Profile Migration

Three distinct messages surface during legacy config seeding, and they do not mean the same thing. Reading the signature correctly is what separates a retry from a rollback.

Environments that rely on concurrent runtime instantiation without throttling should delay the upgrade, and validate the seeding function in an isolated namespace before production rollout.

Executing Migration Steps to Resolve Loading Errors

Scheduling the Migration and Verifying the Seed

The four-step transformation runs unattended, yet it still needs manual operator verification when the interface displays "Uh oh! There was an error while loading".

Moving cloud extensions into the open-source repository centralizes development yet adds a transient dependency on stable network connectivity during the initial profile generation phase. Schedule migrations during off-peak hours to avoid the sandbox pausing that silently halts older instances, because an unseeded profile leaves the agent unable to execute tasks until someone reconciles it by hand.

Clearing the Concurrency Queue to Restore Seeding

The specific "Uh oh! There was an error while loading" message in cloud-1.36.0 indicates a race condition where the UI attempts to render assets before the legacy config seeding completes. This failure mode frequently correlates with rate limiting. Operators must manually intervene because the automated parser cannot recover from silent sandbox pausing without explicit configuration changes.

1. Halt all active agent sessions to clear the concurrency queue and prevent further rate limiting triggers.
2. Access the server-side logs to verify the Default LLM profile seeding status independent of the broken UI layer.
3. Restart the service to apply the synchronous flag, ensuring the context_window mapping completes before the interface initializes.

Reduced throughput occurs during the upgrade window as synchronous loading blocks new requests until the model_name mapping finishes, and enterprises processing over 100 million tokens monthly feel even a brief halt. Schedule it off-peak.

Pre-Migration Validation for Model-Agnostic Profiles

Verify legacy parameter keys against the cloud-1.36.0 schema before executing the seeding process to prevent agent initialization failures.

1. Inspect configuration files for deprecated monolithic strings that conflict with the new model_name field requirements.
2. Confirm model-agnostic compatibility by ensuring target backends like Claude Opus 4.6 or Devstral are explicitly supported in the destination environment.
3. Validate network policies allow outbound connections to isolated sandboxes, a flexibility distinct from IDE-locked alternatives like GitHub Copilot.
4. Check that enterprise licensing covers required features like VPC isolation if deploying beyond the standard trial period.

Skipping validation forces the parser to guess data types, often triggering the "Uh oh! " loading error when raw token limits fail integer conversion. Unlike origin-only validation in routing, this process requires full path transparency of the configuration file structure. Agents fail to load when operators omit this step, halting the entire migration wave. Treat this checklist as a hard gateway, not an optional review.

The Cost Case Behind the Migration

When Self-Hosting Pays Back the Migration Effort

The migration effort only pays for itself above a volume threshold, which is what makes the seeding failure expensive rather than annoying. Inference between $0.20 and $1.05 per resolved task is the variable expense, while custom enterprise pricing for features like Virtual Private Clouds adds fixed costs that must be amortized over high task volumes, against upfront capital that industry benchmarks place at $100,000 or more for custom enterprise multi-agent systems. Low-volume deployments may fail to break even despite efficient per-task economics, and the cost-per-task metric stays misleading until it accounts for idle capacity in bursty workloads and for the concurrency limits that pause sandboxes mid-seed.