Fleet pane: inspect and message native agents across machines

[lukemaj]

Outcome

One T3 Code pane to see and control the agent fleet across connected machines. Discover externally launched agents, inspect their work live, and message any agent in its existing native session across Codex, Claude Code, OpenCode, and Grok CLI. This includes the brain/planner, dispatcher, and implementation agents.

This advances the approved fork Objective: make T3 a working control surface across machines and harnesses, starting with one externally launched dispatcher and expanding the proven integration.

Problem

Agents work across separate harnesses and machines. The user needs one place to understand what each agent is doing and send it an idea, question, or correction while it works, without moving orchestration into the UI or starting a replacement conversation.

Solution and boundaries

Extend T3's existing agent pane, transcript view, and composer. Each connected environment supplies its available native sessions; the pane combines them with clear machine, provider, session identity, and status. Select an agent to inspect its work and message it.

T3 integrates with native harness session discovery, event/transcript streams, and messaging interfaces. Model Router continues managing routing and delegation. No Router chat API, inbox, transcript parser, or replacement dashboard. If a native launch mode must change to permit attachment, prove that need before proposing the narrow change in its owning repository.

Use existing T3 connections and authentication for remote environments. Offline machines remain distinguishable from idle agents. Do not introduce a new fleet broker or persistent service without evidence that existing facilities cannot meet the requirement.

Acceptance criteria

• A single pane lists agents across connected machines and all four supported harnesses, including sessions launched outside T3.
• Each agent is distinguishable by machine, harness, and stable native session identity; role and model are shown when available without guessing.
• Selecting an agent shows its available history and live messages, tool activity, and results as the harness exposes them.
• The user can message every supported agent role in its existing native session and see the response.
• Delivery reflects the harness's real semantics: active-turn steering versus a queued follow-up is visible; failures are explicit and never shown as delivered.
• Viewing or disconnecting T3 does not stop the agent, change its permissions, duplicate its session, or take ownership of its process lifecycle.
• Reconnection preserves session identity and history without duplicate agents or duplicate message delivery. Uncertain delivery is surfaced rather than blindly retried.
• Local and remote agents use the same interaction; unreachable environments and ended sessions have truthful status.

First milestone: one dispatcher

Use one Codex dispatcher launched outside T3 on one machine. Prove the complete interaction before adding more providers or fleet discovery machinery:

1. Start a bounded task through the actual dispatcher launch path and record its native session identity.
2. Find it in the T3 pane and observe live work in the transcript.
3. Send a uniquely identifiable question or instruction from T3 while the dispatcher is active.
4. Observe receipt and a response in that same native session, with the original task continuing correctly.
5. Disconnect and reconnect the T3 view; verify the same session, no repeated message, and uninterrupted agent ownership.

A historical transcript import, copied session, resumed fork, or a second process with the same saved thread identifier does not prove live attachment. A mocked adapter alone does not satisfy this milestone.

Implementation and testing decisions

Reuse the existing provider adapters, agent panel model, transcript rendering, and composer wherever they fit. Keep differences between native harnesses at the adapter boundary. Preserve provider-specific capability reporting rather than pretending every transport behaves identically.

The highest proof seam is the real T3 client through its server to an externally launched native agent. Add focused regression tests for identity, event continuity, message delivery, and disconnect behavior. Start the first milestone in an isolated T3 home. Do not mutate the user's live T3 database.

After the dispatcher proof, apply the same acceptance contract to the brain/planner and workers on all four harnesses, then verify one pane against at least two connected machines. Assess shared web/desktop behavior and mobile compatibility explicitly; one client's success is not evidence for all clients.

Non-goals

Changing model selection, routing policy, agent orchestration, or the brain/planner workflow; replacing native harnesses; building a new dashboard; remote provisioning; fleet billing; automatic deployment; or implementing unrelated controls such as mass termination.

Blockers and unknowns

No product decision blocks the first experiment. Native attachment and messaging to the actual live externally launched instance remain unproven per harness. Test the existing launch path first. If attachment fails, retain the exact failing behavior and assess the smallest native launch/transport adjustment instead of adding a Router messaging service.

Remote reachability and a second connected test machine are required for fleet acceptance, not for the first local dispatcher proof. A provider that cannot yet accept messages remains incomplete against full scope.

Required proof

Record the tested T3 commit, harness version and launch mode, machine/environment identity, native session identity, and sanitized evidence of live activity, message receipt, response, continued task execution, and reconnect behavior. Repeat across four harnesses and at least two machines before claiming fleet completion. Do not publish credentials, private transcripts, or connection tokens.

Simplification decision

The wanted result is visibility and direct communication with existing agents. Prior source inspection found reusable T3 panel/transcript/provider components and native session facilities. Cut the proposed Router inbox, Router transcript parsing, replacement UI, and speculative permanent services. The smallest surviving test is one existing dispatcher, one pane, one live message round trip. Its current constraint is proving attachment to the real running native backend, not constructing a session-list UI.

Approved fork direction

Vision: One surface to understand and direct the entire agent fleet, across every machine and harness.

Mission: Extend T3 Code with a fleet management pane that lets users discover agents, inspect their work live, and message them directly through their native harnesses. Keep orchestration and routing in their existing tools.

Objective: Make T3 Code a working control surface for agents across connected machines, covering Codex, Claude Code, OpenCode, and Grok CLI. Users can see agent status, inspect live sessions, and message any agent, including the brain/planner, dispatcher, and implementation agents.

Start by proving that one externally launched dispatcher appears in T3, streams its work, and receives and answers a message in the same native session without disrupting its ongoing task. Expand that proven integration across agents, harnesses, and machines.

Delivery

Implementation belongs in toolboxmd/t3code. This issue is the canonical saved spec and implementation tracker. Begin with the dispatcher milestone; expand only after its native integration proof. Upstream contribution is a later step subject to the upstream contribution process. This spec does not claim implementation, live verification, deployment, or upstream acceptance.

[lukemaj]

Implementation started in isolated worktrees:

• T3: branch feat/1-agent-fleet, base b2b43bef73447c483ceae486890cb79f01c369cb, approved direction checkpoint 5e646e2e5. Model Router job t3-fleet-pane-1-complete now owns completion of the first Codex pane slice.
• Native dispatcher transport: authorized by the user, tracked in Expose the live Codex dispatcher through its native app-server transport model-router#86, branch feat/86-native-dispatcher, base 7e64edfe56aae9290b01bdbb4a69ad0dddaecd51, current continuation job t3-fleet-router-86-complete.

Native Codex 0.156.1 experiment: a separate server reading an active exec thread reported it notLoaded; the native queue accepted a message, but the original exec turn completed without the requested acknowledgment. That is not sufficient messaging proof.

The replacement transport experiment passed: one temporary loopback WebSocket app-server, two clients, a loaded native thread and one active turn. The observer attached with metadata-only thread/resume, sent turn/steer with the original expectedTurnId, and both clients observed the response and original task completion in that same turn. After observer disconnect/reconnect, thread/read recovered the same history. No native permissions changed and no session fork was created. This proves the native transport, not the T3 UI or actual Router integration yet.

The first implementation milestone remains one real dispatcher. Full four-harness/two-machine acceptance remains open. No Router inbox/chat API, Router transcript parsing, or replacement UI is being introduced. Both jobs use installed routing policy 2.7.0, hard lane, beginning with Muse free. No merge, release, installation, or deployment authorized.

The initial jobs were cancelled before edits after startup inspection found missing direction-loader PATH and an incorrect default planner-model metadata value. The replacement jobs above explicitly carry the canonical loader PATH and Codex planner model.

Additional native proof: disconnect and reconnect during an active Codex turn passed on both Cavallo (0.156.1) and user-authorized Rocky (0.153.4). Original task and message acknowledgment completed in the same native turn. The eventual cross-machine product test uses T3 remote connections, not Codex remote-control as the fleet surface. T3 UI proof remains pending.

The host upgraded the installed Model Router cache to 0.29.1 during the jobs. To preserve in-flight 0.29.0 processes, the exact original runtime commit d1e0c149d9acb10d8a05aa65ee76afb08d5dc6be was restored in private runner recovery storage, with a temporary compatibility link at its previous cache path. Installed plugin selection remains 0.29.1. Retire that compatibility link after these jobs and their children finish.

Coordinator rejected the initial T3 scaffold as incomplete. Commit b33d0691e3b4e3d18562ae20f980d9bbc9b6166d is preserved in draft PR #2. Its helper tests pass, but there is no production WebSocket transport, RPC/discovery wiring, or connected composer yet. It is not a working fleet pane. The old job was cancelled after a second plugin-cache removal broke dispatcher resume (codex_resume_failed rc=127); recovery refused the sticky block. The replacement job owns the same branch/worktree and PR, with explicit real-protocol corrections and end-to-end wiring acceptance. Requested route remains policy 2.7.0 Muse free xhigh; initial worker observed opencode/muse-spark-1.3-contributor-free xhigh. New job carries Observer task t3code-1.

T3 built-in Browser tools are now available in this thread (preview_status: available true). Integrated UI verification can use the required native Browser path once the implementation is connected. No product UI success is claimed yet.

Additional Grok native evidence (not product acceptance): isolated Grok 1.0.41 leader, two ACP stdio clients, native session/list after first prompt, session/load on the same ID and observer session/prompt passed. Both clients streamed the observer reply containing a marker only present in the original conversation. Observed model Grok 4.7 medium. Empty sessions were absent from the initial native listing. Active-turn steering and reconnect remain unverified for Grok. Probe-owned processes were stopped.

Rocky isolated checkout is /tmp/t3-fleet-1.zImhyw/t3code, cloned at the T3 scaffold candidate while dependencies are prepared; it will be updated to the integrated exact candidate before proof. No live T3 state is used.

Additional Claude native evidence (not product acceptance): Claude Code 2.1.281 --bg, agents --json, and attach gave a live native terminal round trip. Session 355fa1e8-b3f6-410b-901e-973a1e850333 answered a marker question from the attachment. After Ctrl+Z detached the viewer, native discovery still reported the same running PID 18802 and session ID; the disposable session was then stopped explicitly. This proves native terminal attachment for background sessions, not structured SDK attachment for arbitrary foreground/headless sessions. No new Router transport was added for Claude.

Cavallo isolated T3 dev server now runs from the task worktree using Node 24.13.1 with home /tmp/t3-fleet-spec/cavallo-home, server port 14000, web port 5960. Built-in Browser successfully paired; application load/proof pending. Rocky dependencies installed with Node 24.13.1 and pnpm 11.10.0.

T3 remote baseline now verified through the real built-in Browser client: Cavallo web http://localhost:5960 paired Rocky at https://rocky.napoleon-sun.ts.net:5734 using existing T3 pairing. Both environments appear in onboarding; a disposable Cavallo project is open in the existing Agents pane. Screenshot baseline at scaffold SHA b33d0691e3b4e3d18562ae20f980d9bbc9b6166d shows no external agents yet. Rocky sharing needed a task-local wrapper invoking its existing Tailscale app executable; no global installation or manual serve configuration. Old task-owned server PID 87373 was stopped after the initial sharing restart left it orphaned. Current remote home remains isolated.

OpenCode 1.18.32 native probe passed with authenticated Go Muse: session ses_f2ba6eef6ffejrEW2OTLAnZbJy, native discovery, observer follow-up with original conversation marker, native history and 51 session-related SSE events. Free-tier probe failed with OpenCode's free tier can only be used from within OpenCode; no success was inferred from that run. The subscription probe separates native transport behavior from the free-tier restriction. Probe-owned server stopped.

Current handoff: the timed-out Router job is cancelled. Coordinator preserved its candidate in 651c1a5 and completed critical transport repairs in e5609d0d2e6c0d24406a08f5d9b1886951b30742. All 37 focused native tests pass. The actual native driver launch passed same-session message acknowledgment, original task completion, reconnect history, inherited launch lock retention and owned cleanup on Codex 0.156.1. Full controller compatibility tests still need repair and complete proof; details remain at model-router#86 comment 5818533885.

Both implementation workspaces are now exclusively owned by their Luna-managed continuation jobs: t3-fleet-pane-1-complete and t3-fleet-router-86-complete. Requested/observed implementation route is now Muse xhigh on Go after free-pool exhaustion; dispatch uses policy Luna Go fallback. Coordinator owns acceptance/review and escalations, not concurrent source edits. The user called out excessive coordinator implementation and repeated investigations; remaining work stays with these dispatchers.

T3 production transport/RPC/client wiring is in progress, uncommitted above b33d069. No working pane milestone is claimed. The isolated Cavallo provider setting now points to a task-owned native endpoint; no message has been sent through the UI. Server reloads during source edits briefly showed the boot screen and recovered. Native Browser DOM interaction works, but snapshot currently reports PreviewAutomationExecutionError. Final live verification waits for a stable exact candidate.

The task-owned native fixture server is PID 88481, start identity Thu Sep 24 19:29:54 2026, loopback ws://127.0.0.1:54967, native thread 01a0d471-509a-7342-9ca3-187346c11975. It runs the immutable Router e5609d0 snapshot from temporary task storage, separate from the active writer. Stop it only through its recorded ownership after testing. Cavallo/Rocky isolated T3 servers remain available. No final review, full fleet acceptance, merge, release or installation has occurred.

[lukemaj]

Worker checkpoint: draft PR #2 contains scaffold commit b33d069. Coordinator rejected this as incomplete because production transport and UI wiring are missing. Current handoff: #1 (comment)

[lukemaj]

Superseded by the confirmed fork direction (#5): T3 spawns the agents itself instead of discovering externally launched ones. Delivered through #10 (child threads), #15 (thread scope) and #17 (Agents panel). Closing.