Debugging an agent session together
Published July 28, 2026 · by the AQ team
When an agent session goes sideways in AQ, help means opening a link, not scheduling a call. A teammate enters the same workspace and sees the identical live terminal, the same working tree in the editor, and the same running app in the preview. And when watching is not enough, they can get the keyboard too: a control request the session owner approves in one click.
Stuck agent sessions are a genuinely new kind of debugging. The agent is mid-task with accumulated context, the working tree is half-modified, and the question is usually "should we redirect it, or roll back and re-prompt." That is exactly the judgment call a second pair of eyes is for, and it is miserable over a screen share where one person narrates a terminal and the other squints.
The second person sees everything, live
A shared workspace is not a video of your screen; it is the session itself. The teammate scrolls the terminal history to catch up on what the agent tried, inspects the files it touched in the editor, and clicks the preview to see current behavior. Catching up takes a minute and requires nothing from the person asking for help: no pushing half-done work, no copying transcripts into Slack.
Both hands on the wheel, with consent
Typing in someone's session is deliberate, not ambient: the helper requests control, the session owner grants it with one click, and from that moment both of them can drive: the senior engineer interrupts the agent and gives it the corrective prompt while the owner stays fully in control throughout, able to jump back in or end the grant at any time. The agent keeps its context; nothing restarts; every keystroke belongs to a named person. This is the pattern teams used to fake with tmux over SSH, minus the shared Unix user, the SSH key ceremony, and the anyone-can-type free-for-all. The comparison is in sharing a live agent session.
Reproduce it in the preview, fix it in the prompt
Bugs that only make sense when you see the app are the preview's job: both people look at the same running dev server, click the same broken flow, and agree on what wrong looks like. A comment pinned on the preview at the broken spot can go to the agent as its next instruction, which closes the loop in one place.
It works across timezones and after hours
Sessions run server-side, so the stuck 6pm session is still alive and fully readable when a teammate in another timezone arrives at their morning: scrollback, diff, and preview tell the whole story. The original pane's keyboard stays with its owner until they delegate it, so the overnight teammate continues the work from their own terminal in the same workspace, on the same branch, with their own agent sign-in. For distributed teams this turns "blocked until tomorrow" into "unblocked overnight"; more on that pattern in AQ for remote teams.
Frequently asked questions
Can a teammate type into my agent session?
With your approval, yes. Everyone with workspace access watches the same live terminal; when a helper wants to type they request control and you grant it in one click. You keep your own input the whole time, so you are pairing, not handing over, and nobody types in your session without your say-so.
Does joining a session disturb the agent?
No. Opening the workspace attaches you to the same running session; the agent continues exactly as it was until someone deliberately prompts or interrupts it.
How does the helper get context on what already happened?
The terminal scrollback is the log: what the agent was asked, what it ran, what failed. Combined with the diff in the editor and the current preview, a helper typically has enough context in under a minute.
What if the session was started by someone who is now offline?
The session keeps running on the server and stays fully readable: scrollback, diff, and preview are all there. Typing in that exact pane waits for its owner's grant, but the work does not wait: open your own terminal in the same workspace and continue the branch immediately.