How ACPX Controls Codex and Claude via Agents

The simplest way to understand ACPX is that it gives you a runtime and control surface around agent backends that would otherwise feel more manual and brittle. That is why its recent release notes spend so much time on turn handles, persistent session reuse, history preservation, and runtime controls.

The Basic Control Flow

At a high level, ACPX sits between your CLI or embedding layer and the backend agent session. That lets the runtime own things like session creation, prompt flow, configuration options, terminal capability negotiation, queue ownership, and history.

The reason this matters is simple: once those pieces are centralized, you can improve them without rewriting the behavior of every backend separately.

Turns, Controls, and Runtime Handles

One of the most interesting 0.6.0 additions is startTurn(...) handles for embedders. The release notes say these let embedders observe live runtime events separately from terminal completion, cancel a turn, or close only the event stream while preserving compatibility with the old flow.

That is a strong hint about ACPX's role. It is not just pushing text through. It is giving higher-level tools a cleaner way to watch and control agent execution in flight.

Why Persistence Is the Hard Part

Manual agent workflows usually feel okay until you try to keep them alive. Then the pain shifts to reuse, stale history, missing prompts, wrong working directories, failed adapter handoffs, and sessions that look dead when they are merely detached. ACPX 0.6.0 addresses all of those failure classes directly.

That is why a control layer matters more over time. The longer the workflow lives, the more valuable recovery and consistency become.

What This Means for Real Operators

If you run Codex or Claude in serious repeated workflows, ACPX gives you a way to stop treating every turn like a fresh manual interaction. The benefit is not only speed. It is lower session friction and more predictable runtime behavior.

That is also why ACPX and session-supervision products belong in the same buyer conversation. Both are trying to make repeated agent work less fragile, just at different layers.

Primary sources

• the ACPX 0.6.0 release notes, particularly the turn-handle, persistence, queue, and session-history notes.
• the ACPX repository, for the project context around ACPX as a public control layer.
• the ACPX README, for baseline usage framing beyond the single release snapshot.

Recommended products for this use case

• Session Supervisor — Best fit if your current sessions are fragile and the main job is making them survive disconnects and restarts.
• Persistent Dev Orchestrator — Best fit if you want the next layer up: background orchestration across multiple agents and tasks.
• Operator Launch Kit — Best fit if you want to shape your own Codex-or-Claude operator instead of improvising the role structure.

Limitations and Tradeoffs

ACPX is still a runtime layer, not a magic abstraction that removes backend differences. You still need to understand what Codex, Claude, or other adapters can and cannot do. The win is cleaner control and persistence, not perfect backend uniformity.

Related Guides

• What Is ACPX?
• ACPX 0.6.0 Release Highlights
• OpenClaw vs Codex for Long-Running Agent Workflows
• How to Set Up OpenClaw Multi-Agent

FAQ

Is ACPX only for Claude?

No. The 0.6.0 release explicitly mentions Claude-specific system prompt forwarding while noting Codex and other agents ignore fields that do not apply.

Why are turn handles important?

Because they let higher-level tools observe and control execution while it is happening instead of waiting for one terminal-shaped result.

What problem does ACPX solve first?

It makes repeated agent control cleaner: session reuse, lifecycle control, cleanup, and recovery.