Is Agent Bridge live yet?

The current page is a front-end demo. Real remote execution, machine registration, and WebSocket-backed session control are in progress.

What does Agent Bridge connect to?

The planned product connects a browser UI to remote machines running Codex, Claude Code, and tmux-backed coding workflows.

Why use a web UI for coding agents?

A browser control plane makes session state, permission prompts, patch review, and machine onboarding easier to manage than raw terminal-only workflows.

Demo experience live, remote backend in progress

Run Codex and Claude Code from a web control plane built for serious developers.

Agent Bridge is a remote AI coding workspace concept for browser-first control of tmux-backed coding sessions, permission gates, patch review, and machine onboarding. This page is a front-end MVP demo of the workflow we want to ship.

Open Interactive Demo Get Beta Access

Machine model

Host agent

Browser UI + remote daemon

Session flow

CLI-first

Codex and Claude Code wrapped cleanly

Primary UX bet

Approvals

Permissions and patches outside raw terminal noise

Machine status

buildbox-hyd-02

Connected

Active agents

2 sessions online

Claude Code in tmux: claude-main

Codex in tmux: codex-main

Pending action

Filesystem write approval

Frontend captures permission prompts and routes them into a cleaner control surface.

Interactive MVP

A better browser workflow for remote coding agents.

This MVP is front-end only. It simulates machine onboarding, session transport, terminal updates, permission flow, and diff review while the real host daemon and WebSocket transport are being built.

Remote hosts

Machine registry

1 online

buildbox-hyd-02

Ubuntu • tmux • codex • claude

Session tabs

Live output

Claude Code / frontend routing fix

Permission queue

Approvals

1 pending

Filesystem write requested

Agent wants to update routing and patch the subscription fallback.

Target: /app/routes/agent.tsx

Reason: expose websocket event stream to UI shell

Patch preview

Change set

diff --git a/app/routes/agent.tsx b/app/routes/agent.tsx

+ const ws = new WebSocket(agentHostUrl)

+ ws.addEventListener("message", routeEvent)

+ setPermissionQueue(events.permissions)

- pollSessionOutput()

4 files changed • 61 insertions • 18 deletions

What this demo proves

MVP coverage

Machine attach and host presence

Session switching across Codex and Claude Code

Approval cards and patch review outside raw terminal output

Operator-friendly onboarding for remote systems

Planned architecture

Browser UI first. Remote daemon next. Structured control after that.

The real product will start with a WebSocket-based control plane rather than jumping straight into peer-to-peer complexity. That keeps the transport simple, lets us normalize Codex and Claude events, and gives us a clean permission layer before we optimize lower-level execution.

1. Browser

Agent shell

Terminal output, approvals, diff review, machine list, and attach flow in one web UI.

2. Gateway

WebSocket broker

Auth, session routing, event fan-out, and audit history for browser clients.

3. Host daemon

Machine adapter

Runs on the remote box, checks tmux and CLI capabilities, and converts local state into structured events.

4. Existing CLIs

Codex + Claude Code

We start by wrapping your existing coding workflows instead of replacing them with a new agent stack.

Early access

Want access when the real remote backend is ready?

Join the waitlist for real machine onboarding, tmux-backed sessions, permission cards, and remote coding control. Right now this is a demo experience. The actual host daemon, WebSocket layer, and session transport are in active development.

Beta signup

Get the launch note

In progress

This page is a demo. Sign up and we’ll notify you when live remote execution, machine registration, and browser approvals are ready.

Questions teams will ask

FAQ

Is this page running real remote sessions?

No. This is a front-end MVP that demonstrates the user experience. Real machine registration, WebSocket transport, and remote execution are still being built.

Why not just stay in tmux?

tmux is great for persistence, but not for session visibility, approvals, operator onboarding, or patch review when multiple agent sessions are running.

Why start with Codex and Claude Code?

Because the fastest path is to wrap the CLIs already used by higher-context developers, then improve the workflow around them before building a deeper agent platform.