OpenClaw’s Kiro ACP Retry Fix Shows Why Multi-Agent Platforms Need Error Taxonomy, Not Hope

OpenClaw PR #93642 is a one-line regex-sized fix with a platform-sized lesson: multi-agent systems do not become reliable just because everyone agrees to speak the same protocol. Eventually a backend says “Internal error,” the thread keeps looking alive, and the orchestrator has to know whether that means “retry safely” or “surface the failure before you duplicate work.”

The PR fixes a Kiro-specific ACP persistent-session failure where stale thread-bound sessions returned Persistent ACP session <id> could not be resumed: Internal error. OpenClaw already recognized Claude-shaped stale-session errors such as Resource not found and No matching session. Kiro wrapped the same underlying condition differently, so OpenClaw left the thread in the worst possible state: active enough to show processing signals, dead enough not to produce a normal reply.

That failure mode should make anyone building with agent protocols uncomfortable. A hard failure is annoying. A zombie agent thread is worse, because it keeps the user and the control plane believing something might still happen.

ACP interoperability needs recovery semantics, not just adapters

PR #93642 was created on June 16 at 13:09 UTC and changes two files with 104 additions and one deletion. The core change lives in src/acp/control-plane/manager.runtime-resume-state.ts: add internal error to a narrowly guarded persistent-session matcher. The key word is “guarded.” OpenClaw is not retrying every internal error. It is retrying only when that phrase appears inside the specific wrapper indicating a persistent ACP session could not be resumed.

That distinction is the entire point. Retrying all “Internal error” responses would be sloppy and could hide real failures. Retrying a stale persistent-session identity before any output has been emitted is a reasonable recovery path. The fix clears the stale identity, calls prepareFreshSession, creates a fresh handle without a resumeSessionId, and retries once. The test added for the Kiro-shaped fixture verifies exactly that sequence, and the targeted Vitest run passed 16 out of 16 tests.

The linked issue #87830 came from OpenClaw 2026.5.19 on Linux, routed through OpenClaw -> ACP runtime -> Kiro CLI / Claude Code ACP, using local/gpt-5.4-mini. The symptoms included AcpRuntimeError [ACP_TURN_FAILED], SessionResumeRequiredError, and Kiro’s resume failure wrapper. The reported thread still showed reactions and processing indicators, but never returned a normal text reply.

That is exactly the class of bug that slips past happy-path demos. Most demos start a clean session, run one task, and stop. Real agent systems resume old threads after restarts, backend evictions, CLI upgrades, auth churn, provider-side cleanup, and user pauses measured in days. Session persistence is not a convenience feature. It is the continuity contract.

The protocol is shared; the failure vocabulary is not

ACP is the right architectural direction. It gives tools like Kiro, Claude Code, OpenCode-style runtimes, and orchestrators a cleaner integration layer than terminal scraping or bespoke JSON glued to stdout. But protocols rarely eliminate vendor-specific behavior. They standardize the road; they do not guarantee every vehicle breaks down with the same dashboard light.

This is why error taxonomy matters. If an orchestrator treats backend messages as opaque strings, it cannot make safe recovery decisions. If it over-generalizes, it creates hidden retries and possible duplicate side effects. If it under-generalizes, it strands users in broken threads that could have been safely recreated. The engineering work is not glamorous, but it is decisive: classify failures by cause, recovery safety, output state, and side-effect risk.

OpenClaw’s fix is appropriately conservative. The PR explicitly avoids changing general ACP retry logic, Kiro or Claude initialization, config surfaces, constants, and public APIs. It also keeps retry scoped to the persistent-session-resume wrapper. That means a random internal model failure does not get papered over as a stale session. In agent systems, invisible recovery can be just as dangerous as no recovery. The retry boundary is the product.

For teams evaluating ACP-backed coding agents, “supports ACP” is now too shallow a checkbox. Ask harder questions. What happens when a persistent session ID expires? What happens when the backend evicts state but the orchestrator still has a thread binding? Does the system retry only before output, or can it duplicate a partially completed turn? Are stale-session errors tested per backend, or discovered by users when a thread stops responding? Can an operator see whether the recovery created a fresh session or simply retried the same doomed handle?

The same applies to Kiro’s positioning as an ACP-capable CLI for IDEs and developer environments. Interoperability is valuable precisely because teams will mix tools. But mixing tools multiplies failure dialects. Claude-shaped errors, Kiro-shaped errors, OpenCode-shaped errors, and future provider-shaped errors all need to become tested cases, not tribal knowledge in issue threads.

Practitioner takeaway: test resumes, not just first turns

If you run OpenClaw or any multi-agent orchestrator in production, add session-resume scenarios to your acceptance tests. Start a thread, bind it to a backend session, simulate backend invalidation, and verify the orchestrator either recreates safely or surfaces a clear operator-facing error. Test the partial-output case separately. A retry before output is usually safe; a retry after tool calls or visible content may be a duplicate-action bug wearing a reliability hat.

Also log recovery decisions as first-class events. A stale identity being cleared is useful information. It can indicate backend churn, provider instability, retention limits, or a mismatch between thread lifecycle and session lifecycle. If those events become frequent, the platform should tell you before users start naming haunted threads.

The narrowness of PR #93642 is what makes it good. It does not pretend ACP reliability can be solved with a catch-all retry. It adds one vendor-aware classification for one known stale-session wrapper, with a single safe retry and a test proving the intended path. That is how agent-platform reliability accumulates: not with grand abstractions, but with enough precise recovery semantics that the abstraction stops leaking onto the user.

Shared protocols are necessary. They are not sufficient. The next generation of multi-agent platforms will be judged by how well they understand failure, not how nicely they spell “agent” in a diagram.

Sources: OpenClaw PR #93642, OpenClaw issue #87830, ACPX project, Kiro CLI