Debug it together, in one live session.
Some bugs need more than one head. When that happens, the whole team drops into the same running session, shares the same terminal, logs, and localhost preview, and prompts one agent that already has the repo loaded.
One session, one agent, the whole team on the bug.
No screen-share, no copy-pasting stack traces, no re-loading context five times. Everyone works on the same running drive and prompts the same agent, and every line below is running in production today.
Everyone in the same running drive
A bug is hard to chase across five different laptops. On Coshell the whole team drops into one live session on one running drive, the same filesystem, the same processes, the same state. You are all looking at the real thing, not a copy of it.
Shared terminal and logs
The terminal is shared. When someone tails the logs or reruns the failing command, everyone sees the same output as it streams. No screen-share, no pasting stack traces into chat, no asking what someone else is seeing.
Integrated localhost browser to reproduce
Run the app and open its localhost preview right inside the session, shared with everyone and auto-reloading as the agent works. Inspect the broken element, comment on it, and send that straight to the agent so it is working from the exact thing you saw.
The agent already has the codebase
One agent reads the repo once and keeps it warm for the whole team, so nobody re-explains the codebase to a cold context just to ask their own version of the question. You all prompt the same agent, which already knows its way around the code.
Follow a teammate to the bug fast
Presence shows who is in the session. Follow a teammate to land on their exact view, and use the in-session chat overlay to point at what matters, so the person who found the bug can pull everyone else to it in a click.
Overlap detection while you dig
When two agents reach for the same lines of the same file, the overlap layer catches it and steers the second one before it clobbers the first. Several people can chase the same bug at once without losing each other's fix.
Browser or CLI, same live session.
Open the drive in any browser, or log in once from your terminal with a device code and attach to it by name. Either way you land in the same live session, with presence, follow, and an in-session chat overlay so the person who found the bug can pull everyone else onto it. Your stock OpenCode CLI attaches unchanged, and every action is attributed to a verified identity.
Debugging together, answered
How does the whole team get into the same debugging session?
Open the drive in the browser, or attach from the CLI after a device login. Everyone who joins lands in the same live session on the same running drive: the same filesystem, terminal, logs, and localhost preview. Presence shows who is in, and you can follow a teammate to land on their exact view. The stock OpenCode CLI attaches to the same drive unchanged.
Can several people prompt the agent at once without stepping on each other?
Yes. You all prompt one agent on one running environment, not parallel copies. When two agents reach for the same lines, the overlap layer catches it and steers the second before it clobbers, so several people can chase the same bug at once without overwriting each other. The repo is read in once and stays warm, so the agent already has the context everyone needs.
Can we keep a debugging session private to a few people?
Yes. Sessions have per-session access control: keep one private to you, share it with named teammates, or open it to the whole drive. So a sensitive incident can stay with the on-call group while routine work stays open to the team.
The next hard bug, debugged together.
Open a drive, share the link, and put your whole team in one live session with one agent that already has the repo. Reproduce it, chase it, and fix it without anyone leaving the room.