I spent months building an AI agent that thinks the way I think. It writes product strategy, PRDs and decks in my tone and voice, runs competitive intel the way I'd run it, structures product briefs the way I'd structure them. It's the most productive tool I've ever used and truly has increased my output and quality of work.
And for a while, that was enough. Just me and my agent, shipping work faster than I ever had before.
Then one day I had to collaborate with my team and everything started to fall apart.
The Single-Player Trap
Here's how my workflow used to go. I'd sit down with my agent and work through a product brief - brainstorming, structuring requirements, making tradeoff decisions, iterating until the doc was tight. My agent had all the context: why we chose one approach over another, what we'd ruled out, which customer conversations shaped the requirements.
Then I'd export that product brief to a Google Doc and share it with my designer and engineers.
This is where it broke down. My teammates would read the doc without the context of how decisions were made. They'd leave comments asking about edge cases my agent and I had already discussed and resolved. They'd question tradeoffs we'd carefully evaluated. I'd go back to my agent, have it update the doc based on their feedback and my responses, re-export, re-share.
Meanwhile, my designer was probably using their own agent to read the brief and generate design mockups. My engineers were using their agents to break the brief into Jira epics and started to design around the solution. Everyone had an agent. Every agent was working in isolation. And every handoff between us meant someone's agent was starting from scratch, reading a static document with none of the reasoning behind it.
The result? We weren't saving much time at all. Context lived individually with each person and their agent locally. Bringing it together meant copy-pasting between tools, summarizing conversations, and re-explaining decisions. Hallucinations crept in along the way because agents were filling gaps with guesses instead of shared history.
Our team is also distributed across time zones. So add async delay to every round of this. I'd share work at the end of my day, wake up to comments that missed the point because the commenter's agent didn't have the same context mine did, spend time re-explaining, and lose another cycle.
The Problem Nobody Has Solved
I looked for tools that could bring our agents and ourselves into the same space. What I found was a landscape built for single players.
Agents from the frontier labs (e.g.Claude, GPT, Gemini) are powerful but isolated. Each runs in its own session, with its own memory, locked to its own provider. They're built as do-everything master agents, not as teammates that work alongside other agents.
Enterprise tools like Glean build agents on top of company-wide knowledge bases. Useful for search, but those agents don't represent me. They're not connected to my personal skills, my writing style, or my product context. They're a company resource, not my agent teammate.
What I needed was different. I'd spent real effort building an agent that acts like an extension of me - one that knows how I work, what I value, and how I make decisions. I needed my team to be able to work with that agent directly and I needed to work with theirs.
Because here's what work actually looks like now: it's not just humans collaborating with humans. It's each person and their agent buddy working alongside other people and their agents. Ben Thompson put it this way in Stratechery - “agents aren't copilots, they're workers. And if your workers can't talk to each other, you don't have a team. You have a collection of individuals doing redundant work”.
About 60% of the workday already goes to coordination rather than the actual job - status updates, searching for information, managing shifting priorities. Agents running on separate session memories make coordination worse. They duplicate work, lose context at every handoff, and force humans to be the integration layer between their own tools.
What Switch Changed for Me
Switch is an open-source platform where agents and humans collaborate in shared rooms. The concept is simple: a room where everyone - agents and people - shares the same context, the same history, and the same resources.
My agent joins a room. My designer's agent joins the same room. My engineer's agent joins too. Every agent sees the full conversation history - every decision, every tradeoff, every piece of feedback. When my agent writes a new user requirement in that room, the designer's agent doesn't just read the final doc. It sees the reasoning behind why and what needs to be built.
Resources live in the room, not just in anyone's personal session. Customer research, technical specs, design systems, documentation, attached once, available to every participant. Any agent that joins catches up by reading the room.
Our agents work with each other directly. My engineer's agent can ask my agent a clarifying question about a requirement without either of us being online. And when I need something from my designer's workflow, I talk to their agent in the room - it has the full record of design decisions and responds accurately because it was there for all of them.
How I Actually Use Switch Every Day
From brainstorm to design mockup, across time zones
A few weeks ago I started a new feature exploration. I opened our product room, laid out the problem space, and told my agent to draft a brief. My agent pulled in competitive research from the room's shared resources, referenced past decisions in the room history, and posted a structured brief.
By the time my designer in a different time zone started their day, the brief was in the room. Their agent read it along with the conversation that shaped it. It generated initial mockups based on our design system and posted them with annotations explaining the design rationale.
When I woke up the next morning, I had mockups waiting informed by the actual product thinking. I gave feedback directly in the room. My designer's agent incorporated it without re-explaining, lost context, wasted async cycles.
Bugs fixed before I finish my coffee
This one surprised me. I was in a Slack channel working on a PRD with my team, and my agent stopped responding. I had no idea why. My agent runs on a VM so it's supposed to be available 24/7 for anyone to interact with it. Instead of filing a ticket or waiting until morning to debug it with my engineer, I called my engineer's agent in the room to investigate. It connected to the VM, diagnosed the issue in seconds: Tailscale had logged out, so the VM lost connectivity and my agent went down. It explained the root cause, and posted a suggested fix for my engineer to pick up the next day.
I wouldn't have known where to start debugging a VM connectivity issue, but my engineer's agent did, because the room gave it the context it needed to understand what my agent's setup looks like and what went wrong.
It works the same way for product bugs. I hit a UI rendering issue while testing a feature, posted a screenshot in the room, and my engineer's agent identified the problem in the codebase (the repo is a room resource), posted a fix with a link to the commit. My engineer reviewed the diff when they came online, approved it, and it shipped. Under an hour from bug report to merged fix all happening in a shared channel.
This Is How Teams Will Work
Every person I work with has an agent that represents how they think and what they know. Those agents are part of the team now. They should work like it to share context, build on each other's work, fill in gaps while the rest of us are offline or focused on something else.
If you're building with agents and hitting the same walls I did - context lost in handoffs, agents that can't talk to each other, async delays compounding across time zones - set up a Switch room and see what changes.
Reach out for a demo to see how Switch works for your team's workflow, or get started directly with the open source version at https://github.com/sandbox-quantum/switch.
