Idea: observer mode for ACP threads — follow an agent that is driven outside T3 (mirror already-running sessions)

[GadOfir]

What we tried

We run a small "factory" of long-lived coding agents (each one is a session of our own agent harness, which already speaks ACP). We wanted T3 Code to be the window onto those already-running agents — open the T3 client on a phone or a desktop, see the list of live sessions, watch each one's text and tool calls as they happen, and (later, with guards) send a line into one.

With the ACP Registry provider this gets surprisingly far with zero glue: a ten-line provider entry, and T3 lists and imports a real running session . We also wrote a tiny read-only ACP agent that tails one session's JSONL and streams it to T3 as ordinary agent updates — median 0.8 s from the line being written to T3's ingress.

Then it stops: the replayed history on session/load never reaches the thread (that's #22015, accepted), and updates that arrive outside a T3-driven turn are dropped — so an agent driven from elsewhere looks idle in T3. The maintainer comment on #22015 named this second part as new behavior and asked for it here.

Why it matters to us

T3 is the best client we've found for exactly this shape (threads, mobile, pairing, no account needed for a self-hosted server). The agents already exist and are driven by their own orchestration; what we lack is a humane way to watch them. Every other road we evaluated (a bridge reimplementing T3's server protocol, or a fork) is days of work to recreate what T3 already does well. Mirroring is a read path; it doesn't need T3 to own the turn.

The fastest road we see

An opt-in observer mode for ACP threads, scoped to the ACP Registry flavor:

1. On import/load, show the session's existing history in the thread (the gap in [Bug]: Imported ACP sessions never show history or root-session output outside a T3 turn #22015) — history appears.
2. When observe: true (per provider entry, or per thread), show agent output that arrives with no active T3 turn in that thread, exactly as if a turn were running, and mark the thread "live (external)". Permission requests in that state are surfaced read-only (no approve/deny), since T3 doesn't own the turn.
3. Keep the existing behavior when observe is unset — nothing changes for today's users.

That's a small, opt-in change on top of the import path that already exists, and it unlocks the "follow an agent that's also driven from a terminal or another client" case without T3 taking ownership of sessions it didn't start.

Happy to test against a real multi-agent setup and report timings; we have the read-only bridge and the measurements ready.

[Ribelio]

Same setup here. A small read-only ACP agent lists every running agent on my machine (pi, Claude Code, Codex) as a native session, and I import each into T3 to watch it from my phone.

#22155 fixed the history on import, so this is the part left. Updates outside a T3 turn are dropped, so my agent answers every prompt with a catch-up of what happened since the last one. Following the session live would remove that workaround. Happy to test a build too.

[wSedlacek]

Note

🤖 Composer responding on behalf of wSedlacek

Prior effort on the “bring an already-running session into T3” side: #34589 (adopt Claude Code sessions from disk into a managed thread).

What we learned trying it

• Discovery + adopt (list / adopt) is workable when the provider leaves durable session files on disk; the UX wants a project-scoped Import entry (settings / sidebar / palette), not only a provider-card affordance.
• Partial real-env verification hit a reachable-UI gap on first import — import must open a thread the client can actually select immediately.
• This is adjacent to observer/mirror mode (watch an agent driven outside T3) but not the same: adopt makes T3 the owner going forward; observer keeps an external driver. Both need a clear story for credentials, cwd, and “who may send next.”