Rysh vs Cursor, Windsurf, and Copilot: editor-bound assistants vs workspace-level agents
Keep your AI editor. Seriously. This is about the layer above it — where agents stop being autocomplete and start being coworkers.
Keep your editor.
Seriously — this is not a "ditch Cursor" post. If Cursor, Windsurf, or Copilot makes you faster, that's real, and nothing below argues otherwise. Tab-completion that reads your mind and in-editor chat that knows your file are genuinely great at what they do.
This post is about a different question: what happens outside the buffer?
The editor is human-first — by design
AI editors share one architecture: a human sits in a buffer, and the AI assists that human, in that editor, on that code. One developer, one editor, one attention span. The AI's world ends at the project window.
That design is exactly right for writing code. And it quietly caps what the AI can be:
- The assistant works when you're working. Close the laptop, the AI stops.
- Two teammates' assistants know nothing about each other. There's no shared view of what AI did across the team today.
- The AI's reach is the codebase. Your ops runbooks, your deploy pipeline, your support inbox — different tools, different silos, usually no AI at all.
- Autonomy is short-leash: suggest, apply, next. Nobody's editor assistant runs a 40-minute task while they're in a meeting — and if it did, who'd be watching it?
None of this is a flaw. It's the shape of the product. Editors are for editing.
Rysh is workspace-level
Rysh starts one layer up: not "assist this human in this buffer," but run agents as peers in a shared workspace.
In rysh, every pane is a conversation. A pane can be your shell. It can be an autonomous agent you spawned from a markdown skill file, working through a task list on its own. It can be a teammate's shared session. The agents don't live inside your editor — they live next to you, addressable by name (@reviewer, @migrator), visible to your whole team.
What that unlocks:
- Agents that outlast your attention. Kick off a task, detach the session, reattach from anywhere — the agent kept working, and every tool call it made is in the pane's history.
- Team-level visibility.
##share pane viewlets a colleague watch an agent work, live.controllets them drive. "What did the AI do?" has an answer anyone can see. - Governance, not vibes. Dangerous operations — destructive shell, file writes — stop and wait for human approval, with a coloured diff of what's about to happen. Safe commands flow.
- Reach beyond code. The same engine that edits files also runs your browser automations and answers on Slack, email, and website chat (WhatsApp and phone are roadmap, not live). Editors polish code; workspaces run companies.
- Agents in git. An agent is a skill file — markdown you review like code, not settings buried in an app.
Under the hood it runs on Claude with your own API key. Same class of model your editor calls — we don't claim a smarter brain, we claim a bigger room for it to work in.
Side by side
| Cursor / Windsurf / Copilot | rysh | |
|---|---|---|
| Unit of work | A buffer, a suggestion | A pane — a running conversation/agent |
| Who drives | The human, always | Human or autonomous agent, gated |
| Scope | The open project | Terminal, browser, channels, APIs |
| Team visibility | None across users | Shared panes, view or control |
| Long-running autonomy | Not the model | Detachable sessions, budgeted loops |
| Governance | Accept/reject inline | Approval gates + full tool-call trail |
| Where it runs | Vendor apps (~$10–40/user/mo) | Self-hostable, your Anthropic key |
When to pick the editors
Honestly: most of the time you're writing code.
- You want completion and refactors in your flow — nothing beats in-editor.
- You're a solo dev; team visibility isn't your problem yet.
- Your AI needs stop at "help me write this function faster."
Cursor and Windsurf are polished products with real momentum. Copilot is the lowest-friction AI a developer can adopt. Keep them.
When you've outgrown the buffer
The tell isn't dissatisfaction with your editor — it's questions your editor can't answer:
- "Can the agent keep going after I close the lid?"
- "Can we both watch it work?"
- "Who approved that delete?"
- "Why does our AI stop at the repo when half our work is ops and support?"
That's workspace-level, and it's what rysh is for. Not a replacement for your editor — the layer above it. Plenty of people run their whole workflow, editor included, inside rysh panes: it's a real terminal (vim works fine), so your tools come with you.
Editor for writing code. Workspace for running agents. You'll want both.
We're building rysh with design partners — teams who use AI editors daily and feel the ceiling. Come define the layer above: become a design partner →
More in this series: Rysh vs Claude Code · Better together: running Claude Code inside a rysh pane