Last month I left an agent running overnight. It started a refactor around 6 p.m., and by midnight it was stuck in a test loop it had already failed twice. I was asleep. A teammate who happened to be online could see a branch name in the commit list and nothing else — not what the agent was trying, not whether it was stuck or grinding, and no way to nudge it back on course. In the morning I got to reconstruct the night from a wall of logs.
That was the moment I stopped treating "share a live agent session" as a nice-to-have. Agent runs keep getting longer, and the practical consequence is that handoffs are no longer optional: if a run takes 18 hours, somebody else on the team is awake for part of it. The question is whether they can watch it — and what happens if they need to step in.
I have since tried every way I could find to share a live agent session, from a tmux fork you can install in thirty seconds to vendor dashboards to team platforms. This post is that list. Every tool is linked to its official site, and each is judged on the same four criteria.
TL;DR
- Need eyes on it right now, will delete the setup after: tmate or sshx. Sharing the terminal itself is the oldest trick here and still the fastest.
- Your team lives inside one vendor's tools: use that vendor's native sharing — Claude Code on the web, Cursor's team dashboard, or Devin's session viewer.
- Your team runs agents from several vendors, and QA or PMs need to see work too: you need a cross-agent team layer — GitHub's Agent HQ, Multica, Linear for Agents, or Sharkly.
- The dividing line is not "can a teammate watch" — most options can do that now. It is whether the teammate who takes over inherits the context, or starts from zero with a wall of logs.
What "sharing a session" actually has to mean
"Sharing" covers four capabilities that are easy to conflate, and I now judge every tool on all four:
- Watch live. A teammate sees what the agent is doing while it does it — not a replay after the fact.
- Take over. The teammate can intervene: stop the run, edit the prompt, fix the environment, redirect the work.
- Continue with context. After the takeover, the work continues without losing what the agent already learned — the conversation, the plan, the failed attempts.
- Access control. The right people can watch, the wrong ones cannot, and nobody is handing out SSH keys to the build server.
Plenty of tools do number 1. Fewer do 2. Number 3 is where most quietly fail, and it matters most — a takeover that throws away the agent's accumulated context just converts my teammate's hour into re-orientation time.
The DIY route: share the terminal itself
The agent runs in a terminal, so share the terminal. Two tools do this well.
tmate is a fork of tmux with instant sharing built in. On the machine where the agent runs:
tmate
# outputs something like:
# ssh ro-abc123@nyc1.tmate.io (read-only)
# ssh abc123@nyc1.tmate.io (read-write)
Send the read-only link to whoever needs to watch. The read-write link only goes to someone you trust with the machine, because it is a shell, not a viewer.
sshx takes the same idea to the browser: a shareable URL, multiple terminal panes on an infinite canvas, and read-only or editable links. It has picked up a following in the agent crowd for exactly this use.
I ran both on a Linux box with an agent-style job in the session. sshx worked exactly as advertised: I opened the viewer link in a browser, watched the session live, and a second pane could be opened by anyone with the link:
The limits are the flip side of the simplicity, and I hit all of them:
- It is a stream of text, not a session. The viewer gets keystrokes and output — not the task, the acceptance criteria, the plan, or the diff summary that make an intervention smart.
- A takeover is a hijack. Typing into a shared tmate session means two people fighting over one keyboard. There is no "you take it from here" with a clean handoff.
- Access control is a link. Whoever has the link has the terminal. Fine for two people pairing; not a standing arrangement for a team.
- The session dies with the machine. Close the laptop lid and your teammate stares at a disconnected socket.
For a live-debugging rescue, all of that is fine. As a team workflow, it is scaffolding, not a building. Keep one of these installed anyway — the way you keep a flashlight in a drawer.
Vendor-native session sharing
The agent vendors themselves have been adding sharing, and if a team is anchored to one ecosystem, their answer is often the right one. This is what each offers, from their own documentation:
Claude Code on the web. Sessions can be shared by link: a teammate can open one, read the full conversation history, inspect the diffs, check out the branch, and follow up in their own workspace. Sessions run in Anthropic's cloud sandboxes, with parallel tasks launchable from the browser or phone. The caveat: the sharing applies to web sessions — agents running in local terminals on developer machines are not what the viewer is watching.
Cursor's team dashboard. On Team and Enterprise plans, admins can see every background agent anyone started — status, who launched it, which repo and branch, what it consumed — and jump into any session to review or give feedback. The strongest "manager needs to see what the agents are doing" surface I have found.
Devin's session viewer. Sessions are watchable in real time and replayable after the fact, with shareable session URLs and team-level visibility for org members. For watching an autonomous engineer work — which is Devin's whole model — it is the most polished seat in the house.
Factory's droids sit in the same category, aimed at enterprises: session traces, audit logs, and dashboards built for compliance as much as collaboration.
The honest limitation of this whole group is the word native. Each one shares sessions for its own agent. A team running Claude Code, Codex, and a Cursor background agent has three viewers, three permission models, and no single place where "what are the agents doing right now" has an answer. That is the gap the next group fills.
Cross-agent team layers
These platforms sit above the agents and make sessions a shared team object, whichever agent is running.
GitHub Agent HQ. Announced at GitHub Universe 2025 and rolling out through 2026, Agent HQ turns GitHub into mission control for agents from multiple vendors — Copilot's coding agent alongside Claude, Codex, Jules, Cursor, Devin, and Windsurf. Developers can view, monitor, and steer sessions in real time; leads get audit logs and live dashboards of what agents are doing across the org. If your team's center of gravity is GitHub, this is the natural answer, on Business and Enterprise plans.
Multica. A team workspace for coding agents: shared agent configurations, parallel runs in cloud sandboxes, and an explicit live loop — watch an agent work, take over at any point, hand it back. Sessions are visible to teammates for comments and handoffs, and the org-level story (SSO, audit logs, SOC 2) is aimed at real companies.
Linear for Agents. Linear delegates issues to agents from Claude Code, Codex, Devin, and others, and tracks each session inside the issue — with the spec, the commentary thread, and the review all in one place. Weaker on "watch the terminal live," stronger on "the whole team sees what the agent did and talks about it where the work is tracked." For teams whose day already lives in Linear, that trade is often correct.
Sharkly. A workspace where humans and agents plan and build together: sessions are shared team objects that teammates can watch live and take over, with the task context — not just the terminal — attached to the takeover. Agents run on connected computers you control (your machines or your cloud), and the agents are runtimes you already pay for, like Claude Code and Codex. Free for teams of up to 5.
How to choose
- You debug each other's agents a few times a month. sshx or tmate. Do not buy anything.
- Your team standardized on one agent vendor, and the watchers are engineers. Use the vendor's native sharing — the license is already on the card.
- Your center of gravity is GitHub and you want agents governed like the rest of the org. Agent HQ.
- Multiple agents from multiple vendors, non-engineers who need to see work, and a real question about where code is allowed to run. That is the cross-agent team layer case — evaluate Multica, Linear, and Sharkly on the four criteria and pick the trade-offs you can live with.
How does your team do it — tmux over SSH, a vendor dashboard, or a team platform? If you have hit the "teammate watches an agent at 2 a.m." problem, I would genuinely like to know what you settled on.

Top comments (0)