`##upstream subscribe`: watch a teammate's agent work from your own terminal
No screen share, no SSH, no leaving your terminal. Subscribe to a teammate's shared pane and their agent's work streams into yours.
There's a moment that happens weekly on any team running AI agents: someone says "my agent is doing something weird, look at this."
And then the ritual begins. Start a video call. Share the screen. Squint at 14px terminal text compressed by a video codec. Ask them to scroll up. Watch them scroll past it. Ask them to scroll back down.
Here's the rysh version of that moment. Your teammate, in the pane where their agent is working:
##share pane view
You, on your own machine, in your own rysh session:
##upstream shares
Available shares on upstream:
a3f81c02 pane view halil/payments-debug
##upstream subscribe a3f81c02
Done. Their pane's output now streams into yours, live, every line prefixed:
[remote:payments-debug] $ go test -run TestSettlement ./billing/...
[remote:payments-debug] --- FAIL: TestSettlement (0.41s)
[remote:payments-debug] [agent] Reading billing/settlement.go to check the rounding path...
You're not watching pixels. You're reading text in your own terminal — your font, your colors, your scrollback, your copy-paste. Their shell commands and their agent's moves, interleaved exactly as they happen.
Your terminal stays yours
The detail that makes this feel right in practice: subscribing doesn't hijack anything. The remote stream lands in your pane alongside your own work, tagged with [remote:alias] so there's never ambiguity about what's yours and what's theirs.
You can keep typing your own commands. You can run your own agent. The remote feed is one more voice in the pane, not a takeover of it. When you've seen enough:
##upstream unsubscribe
The stream stops. No call to leave, no window to close.
What's actually flowing
Mechanically: when your teammate shares, their session registers the share with the upstream rysh-server, and an actor on their side forwards the pane's output to a NATS subject scoped to their workspace — ws.{workspace}.share.{shareID}.output. When you subscribe, your session spawns a RemoteShareListenerActor that subscribes to exactly that subject via the upstream, and forwards each message into your pane with the alias prefix.
The upstream server is a checkpoint, not a relay that trusts everyone. Its NATS proxy validates you're an actual subscriber of that share before messages flow, enforces the share's mode, and workspaces are isolated at the NATS subject level — you can't subscribe your way into a workspace you don't belong to.
A pane's output in rysh is also structured — shell output, agent output, and chat are separate streams that get forwarded distinctly. Today the practical upshot is a clean, readable merged feed; longer-term it's the foundation for filtering ("just show me the agent's tool calls").
And yes, this is live — this exact flow runs against the rysh.ai upstream today. It's what we use to watch each other's agents while building rysh itself.
When watching becomes participating
If the share was created with control instead of view, subscribing gets you one more verb:
##upstream send go vet ./billing/...
That command travels up to the server, through the proxy checks (control mode? actual subscriber? not blocklisted?), and lands in your teammate's pane — where it executes in their shell, on their machine, output streaming back to everyone subscribed. Pair-debugging without anyone leaving their own chair, terminal, or timezone.
View-mode shares reject ##upstream send at the server. It's not a UI restriction — the message never reaches their machine.
The scenarios where this clicks
Agent code review, live. Your teammate's agent is refactoring an actor system. You subscribe for ten minutes, watch its tool calls, and say "it's about to miss the codec registration — stop it." That's ten seconds of value that screen sharing makes annoying enough that nobody does it.
The senior-engineer drive-by. A junior runs their first multi-step agent task against a real repo. Their lead subscribes in view mode from another city, watches the approach, drops feedback in Slack. Zero setup cost means it actually happens.
The long-running job vigil. An agent is grinding through a big migration on someone's machine. Three people care. Three people subscribe. Nobody asks "how's it going?" in the channel every twenty minutes, because they can see how it's going.
Learning by watching. Honestly the underrated one. The fastest way to learn how someone gets good output from agents is to watch them work. Subscribing to a colleague's shared pane is an apprenticeship with no scheduling.
Honest edges
- The stream is output-shaped: readable text, not a pixel-perfect replica of their screen. (When they're inside vim, you get the readable text stream, not their full-screen editor UI — more on that in a companion post.)
- What hits their scrollback reaches subscribers. Standard screen-share hygiene applies: don't share panes where secrets will be printed.
- You need an upstream in the middle — rysh.ai's, or your own: the server is self-hostable, and the agents themselves run on Claude with your own Anthropic key. Your infra, your keys, either way.
- It's early software. The flow above is real and live, but we're still shaping ergonomics — which is precisely the feedback we want.
If your team runs agents and you want visibility into each other's sessions to be one command instead of one meeting — we're onboarding design partners now. Direct line to the founders, help shaping the roadmap: rysh.ai/design-partner
Related: View vs control: two trust levels for a shared terminal · Readable from afar: what remote observers see while you're in vim