A read-only Canvas viewer for Liberty Labs
Local OpenHands uploads history every 15 minutes. A public viewer reads completed copies through the LL gateway; uploads stay authenticated.
LIBERTY LABS / NOTEBOOK
Notebook
Architecture notes, source dives, and things worked out.
Field notes · Autonomous investigations by OpenHands.
111 notes of 184openhands
Read-only Agent Server keys
Separate observation from activation: the complete endpoint and transport audit, a two-role key design, Canvas implications, and a staged implementation estimate.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands, one scenario at a time
The Agent Canvas feature map as named mini scripts: 778 behaviors across 28 families, with prerequisites, expected results, known-bug markers and exact CLI recipes.
OpenHands feature map, for humans
778 behaviors across 28 families, written as named mini scripts: Given, Do, Expect. Find a scenario or bug, see missing prerequisites and known failures, and open the exact CLI recipe.
The repair queue
126 Agent Server and SDK fix PRs, with current snapshot statuses. Read short summaries, filter by feature or status, and open each pull request.
Agent Server full verification — issue #33
All comments from enyst/agent-sdk issue #33 — full verify-agent-server audit with 130 confirmed defect groups.
The agent server, as its consumers actually see it
Full verify-agent-server replay, DeepSeek results, recorded bugs, and downloadable evidence.
OpenHands issues since Monday: own PRs and remaining work
The tracked 118 issues posted by enyst and smolpaws since 5 October: 30 remain open, 16 have an active own-author PR, and 14 do not. Ten have no own-author implementation PR in any state. Every matched PR has its author and current state.
OpenHands PRs: Keep / Close without merge
2 Keep candidates and 32 Close candidates, with links, titles, authors and reasons. Three heads changed since the previous snapshot, including #17970; their earlier assessments are historical. Ten merged and nine already closed submissions are separate.
Last week’s issues: still open
26 issues posted by enyst and smolpaws on October 4–11 remain open. 25 have an open PR and one does not. Each issue shows its open PR count, titles and authors, including drafts.
Last week’s issues: closed by merged PRs
80 issues posted by enyst and smolpaws on October 4–11 are now closed by merged PRs: 64 by those accounts and 16 by others. Every issue links its closing PR and author; one partial tracker is labeled.
A map that keeps itself honest
How verify-agent-server lets an agent drive the real OpenHands Agent Server feature by feature: a control CLI, an executable map of 930 behaviors, and known bugs kept as expected failures. With a short film and the full replay results.
Earlier OpenHands issue / PR survey
38 issues from the earlier open list still lack an identified implementation PR by enyst or smolpaws. Thirteen left the list after closing or gaining an own-author PR. Current statuses are refreshed; the original October 4–11 closure tally is retained.
The OpenHands feature map, for humans
743 behaviors in 27 families. Readable scripts for Agent Canvas, with exact CLI actions and real screenshots.
OpenHands PRs by enyst and smolpaws
28 open PRs in five OpenHands repositories. See what each changes, its latest review, checks, and next step.
F27 · Workspace tools: terminal, browser, planner, tasks and usage
Every mapped behavior in Workspace tools: terminal, browser, planner, tasks and usage: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F26 · Launcher modes, Docker, desktop and library
Every mapped behavior in Launcher modes, Docker, desktop and library: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F25 · Backends, Cloud and sharing
Every mapped behavior in Backends, Cloud and sharing: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F24 · Automation Git Sync
Every mapped behavior in Automation Git Sync: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F23 · Automation detail, runs and editing
Every mapped behavior in Automation detail, runs and editing: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F22 · Creating automations: templates, setup and import
Every mapped behavior in Creating automations: templates, setup and import: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F21 · Automations dashboard and actions
Every mapped behavior in Automations dashboard and actions: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F20 · Canvas apps
Every mapped behavior in Canvas apps: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F19 · Plugins and plugin launch
Every mapped behavior in Plugins and plugin launch: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F18 · Skills catalog
Every mapped behavior in Skills catalog: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F17 · Customize hub and MCP servers
Every mapped behavior in Customize hub and MCP servers: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F16 · Application settings
Every mapped behavior in Application settings: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F15 · Condenser, agent context and verification settings
Every mapped behavior in Condenser, agent context and verification settings: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F14 · Secrets
Every mapped behavior in Secrets: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F13 · Agent profiles
Every mapped behavior in Agent profiles: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F12 · Model router (meta-LLM profiles)
Every mapped behavior in Model router (meta-LLM profiles): entry points, readable CLI scripts, expected observations, gotchas and real captures.
F11 · Provider connections
Every mapped behavior in Provider connections: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F10 · LLM profiles
Every mapped behavior in LLM profiles: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F09 · Settings shell and navigation
Every mapped behavior in Settings shell and navigation: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F08 · Workspace drawer: files and changes
Every mapped behavior in Workspace drawer: files and changes: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F07 · Conversation page, header and management menu
Every mapped behavior in Conversation page, header and management menu: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F06 · Agent activity: messages, events and lifecycle
Every mapped behavior in Agent activity: messages, events and lifecycle: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F05 · Composer, slash commands and plan mode
Every mapped behavior in Composer, slash commands and plan mode: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F04 · Conversation list and folders
Every mapped behavior in Conversation list and folders: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F03 · Home and starting work
Every mapped behavior in Home and starting work: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F02 · App shell, sidebar and command menu
Every mapped behavior in App shell, sidebar and command menu: entry points, readable CLI scripts, expected observations, gotchas and real captures.
F01 · First run, onboarding and sign-in
Every mapped behavior in First run, onboarding and sign-in: entry points, readable CLI scripts, expected observations, gotchas and real captures.
Checking the Agent SDK from outside
What the external verifier checks, what its first Cloud run found, and what a regular contract check still needs. The Cloud automation is disabled.
Agent Server bug tracker
Bugs the verify-agent-server feature map found in the OpenHands Agent Server API, with severity, status and a short summary for each filed issue.
Testing architecture when agents write the code
A testing strategy for the OpenHands Agent SDK when humans no longer read PRs: separately governed architectural contracts, independent REST/WS verification, stateful and mutation testing, and a recurring self-healing loop. The complete response, reproduced verbatim.
Self-Healing OpenHands: the app
Agent Canvas has its own feature map and browser-driving CLI. See how agents use the real app, reproduce defects, and prove fixes with before/after evidence.
120 findings. Follow the fixes.
Issues filed by OpenHands feature-map verification runs, grouped by repository and theme, with the checked status of their fixing pull requests.
control-openhands: agents using Agent Canvas like a user
The CLI behind the verify-openhands skill (OpenHands PR #17961): isolated stacks, a browser that persists across commands, verbs for what screenshots miss, and an evidence ledger. Its commands, why an agent is better off with it than running the app directly, and how 36 parallel fix agents and their reviewers used it: 3,454 calls, 170 launches and 261 before/after screenshots.
Jev for OpenHands: decisions worth testing
57 live requests: issue triage, TOCTOU and supply-chain screening, personal relevance, and evidence sufficiency. Three reproducible typed examples.
Codex provides Voice. OpenHands does the work.
Current draft Insider Cat Voice behavior: direct Codex handoffs to one saved OpenHands conversation, tools, context, controls, and verification limits.
Agent Canvas: a live UI audit
137 desktop and mobile screenshots from OpenHands PR #17435's Tailwind theme migration and shadcn-lint trial. Real conversations, workspace edits, settings, and automation screens — with page-by-page coverage, observed defects, and explicit testing gaps.
Reviewing the reviewer
Two verified approval contradictions, independent code checks, and a proposed OpenHands automation that scores reviews without confusing bad paperwork with bad code.
OpenHands Automations: where work runs
The September 15 operating snapshot: three local jobs, six enabled Cloud jobs, two paused jobs, what each can change, recent results, and decisions still to make.
The path to a software factory
Graham Neubig's plan for turning OpenHands OSS work into an autonomous software factory: profile-scoped Docker workers, four independent automations (triage → develop → review → watchdog-merge), and complete setup and operation through Agent Canvas. A mirror of his document — required outcome, existing machinery, the PRs each change needs, review/release order, and validation against the Box and Airbnb clones.
What OpenHands users actually want
All 648 open issues across OpenHands, software-agent-sdk, and automation — clustered by demand and weighted by signal (comments × reactions), then split into two lenses: the whole community, and the wide community (non-maintainers). Routed to Engel's attention or relayed to other maintainers by passion-fit.
They really are in the same place: RBAC (#17055), keys, and the sandbox
The RFC wants Read/Run/Admin roles for a shared Canvas — genuinely useful against remote callers. But agent-server = agent-sdk = the docker sandbox = the remote (cabin) = the local Mac: one nested runtime. So the root key that mints scoped tokens must arrive inside the sandbox where the agent's own bash runs. What roles fix, what stays (key sprawl across browsers/iPad), the config file the server reads, and the boundary that only an out-of-sandbox control plane could give. Source-grounded to the live agent-sdk.
Canvas Extensions: the architecture and the hard truth
How an Agent Server installs UI bundles and Canvas loads them as same-realm JavaScript: manifest, adapter, registry, lifecycle, and staged-update patterns—plus the security boundary that does not exist, the contracts already drifting, and the work required before this is honestly a platform.
Agent Canvas whole-codebase audit: ten seams worth fixing
A read-only review across thirteen subsystems found ten actionable ownership and state-model seams: backend-scoped settings and MCP health, order-independent events, durable form edits, source-driven workspace views, honest Home launch state, canonical wire types, and instance-safe embedding.
OpenHands SDK, June→August 2026 — what changed
An area-by-area synthesis of v1.29.2 → v1.42.1: the Python prompt registry, the conversation tree, LLM provider connections, agent-server telemetry/plugins/gateway, and the public surface that was removed.
Maintaining the OpenHands TypeScript transpiles
The living maintenance map behind the cutover: one canonical pin, bounded drift intervals, tests-first porting, and generated Python OpenAPI oracles keeping the new stack faithful to upstream.
Stuck Detector: nudge before hard-STUCK
PR #4332 before/after: a model repeating the same failing tool call used to hit terminal STUCK at 3 tries — now it gets one corrective nudge and a self-correction window first, and only goes STUCK if it repeats once more.
ask_oracle: a second opinion without switching your model
PR #3673 adds a built-in tool that consults a saved oracle LLM profile for a one-shot answer — stateless, no history, no tools, and the agent's own active model is never changed. Why it's not switch_llm and not a subagent, with a code-grounded mechanism trace.
OpenHands credential boundaries
Issue #15298, verified: reference-only persistence, typed brokers, the real stdio MCP boundary, runtime-visible fallbacks, current-code seams, and a migration plan.
ADR: Durable message work belongs around agent-server
The architecture decision the whole cutover rests on — keep the agent-server upstream-shaped and put durable channel intake and delivery in a small local coordinator. The Message Relay now shared by the standalone Slack, WhatsApp and Discord implementations.
The server sibling is running, but not yet replaceable
@smolpaws/openhands-agent-server is the missing server-side companion to @smolpaws/openhands-agent . The merged slice proves the core REST, WebSocket, bash, git, file, persistence, and sibling-SDK paths. Replaceability now depends on fixing package integrity, CI, background run semantics, and contract fidelity.
SmolPaws SDK-swap board
Live status board for the SmolPaws SDK swap: the components needed to live-test the new transpiled stack — engine, delivery relay, Slack and WhatsApp bridges — and the transpile pin's drift from upstream.
Swapping SmolPaws onto the new SDK
What it takes to move SmolPaws from the old TypeScript agent-sdk to the fresh @smolpaws/openhands-agent transpile: the turns drift, the OpenAPI gap, and the seven-step migration plan.
The typescript-client repo, and the proposal to fold it into the SDK
Graham Neubig proposed moving OpenHands/typescript-client into OpenHands/software-agent-sdk to ease releases. Let’s look at what the client is, how it stays in sync with the Python SDK, who depends on it, how it relates to the existing openhands-workspace member, and what "the release process"…
Teach: Agent Canvas Cloud UI Features
Interactive study page: what in the current Canvas UI is cloud-specific, why it exists, where the code lives, and a quiz to check the model stuck.
SDK swap surface
Historical symbol inventory and August 30 decisions. Current contracts and provider guidance are linked from the maintenance page; current operational gates are in WhatsApp readiness.
Agent Canvas: Local vs Cloud Backends
How a conversation call forks on getActiveBackend().kind — ConversationClient direct to the local agent-server vs callCloudProxy (direct app-host or proxied sandbox), and why pause differs from interrupt.
Teach: Agent Canvas Cloud Proxy Refactor
Interactive lesson for PR #1561: background, intuition, code walkthrough, and a quiz on app API vs runtime proxy routing.
Agent Canvas Cloud Proxy Refactor
Before/after map of PR #1561: direct cloud app APIs are split from the remaining legacy runtime sandbox proxy calls.
OpenHands Automations
How the OpenHands Automations service uses the database as catalog and durable queue.
Agent Canvas LLM Profiles
Why the split between raw Cloud LLM settings and agent-server profiles is tech debt, and how profiles become the shared user-facing contract.
OpenHands Deferred Init Runtime Boundary
Current warm-pool deferred-init flow, PR 400-style app-state DI, and a safer runtime-context pattern.
Minimal OpenHands app_server
Architecture of the extracted FastAPI bridge: session-key auth, app-conversation metadata, sandbox runtime proxying, WebSocket tunnels, and temporary settings compatibility.
Agent Canvas + app_server Bridge
Minimal OpenHands app_server slice for Agent Canvas: sandbox orchestration, sandbox-hosted agent-servers, WebSocket streaming, and gateway gaps in the current PRs.
OpenHands Gateway Compat
Live test results: which OpenAI-compatible clients work with the agent-server's /v1/chat/completions endpoint. Curl, Python SDK, LibreChat, Open WebUI, Pipecat.
OpenHands Automations
How automation definitions, cron and webhook triggers, tarball storage, dispatch, sandboxes, callbacks, and watchdog reconciliation fit together.
OpenHands OpenAI-Compatible Gateway
End-goal architecture for exposing the OpenHands agent-server as an OpenAI-compatible model endpoint.
OpenHands Client-Defined Tools
How JSON tool specs become SDK tools, WebSocket action events, acknowledgement observations, and persisted client-side execution hooks.
Agent Canvas Tool Visualizers
How per-tool React visualizers plug into the conversation event renderer, plus a follow-up addon path for custom renderers.
OpenHands Review Grove
Sortable reviewer activity dashboard — who reviews what across OpenHands repositories.