# WeSesh: Pair Programming with Coding Agents
> Source:
> Published: 2026-11-02 03:41:05+00:00
#
WeSesh is pair programming
for your AI agents.
**TS** rateLimit.ts ···
**Agents in this room**+ Claude Code+ Codex
**alex ·**
**Claude Code**
**~/acme-app** → claude
```
Claude Code v2.1.0
Claude · alex
~/acme-app
```
✔ Working on: Rate limit the upload route
Add rate limiting to /api/upload, 20 a minute per user
Update(src/middleware/rateLimit.ts)⎿ Updated with 24 additions and 3 removals- export const LIMIT = 100;+ export const LIMIT = 20;
Limiter is in. Messaged sam's agent so it can write the tests.
✻ Thinking… (41s)
**sam (you) ·**
**Codex** ready for a prompt
**~/acme-app** → codex
**model:** gpt-5-codex /model to change
**directory:**~/acme-app
Write tests for the upload rate limiter
Ran npm test -- rateLimit
codexAdded 6 tests in rateLimit.test.ts. All passing.
Brewed for 18s
# Room plan
Goal: Harden the upload API
One line per piece of work. Each person's AI takes only the lines with their name.
- [x] Rate limit uploads · files: src/middleware/rateLimit.ts · owner: alex/Claude Code
- [x] Limiter tests · files: src/middleware/rateLimit.test.ts · owner: sam/Codex
- [ ] Retry-After header · files: src/api/upload.ts · owner: alex/Claude Code
- [ ] Document limits · files: README.md · owner: sam
```
1import type { Request, Response, NextFunction } from "express";
2
3export const WINDOW_MS = 60_000;
4export const LIMIT = 20;
5const hits = new Map();
6
7export function rateLimit(req: Request, res: Response, next: NextFunction) {
8 const now = Date.now();
9 const recent = (hits.get(req.ip) ?? []).filter((t) => now - t < WINDOW_MS);
10 if (recent.length >= LIMIT) return res.status(429).end();alex
11 hits.set(req.ip, [...recent, now]);
12 next();
13}
```
**src/middleware/rateLimit.test.ts**: limit reached, window reset, per-user counting, and three edge cases.
**alex** prompted your Codex: add a test for the Retry-After header×
Why WeSesh
## Your whole crew. Every agent.
One codebase that keeps up.
### Prompt your teammate's AI.
Type into their Claude Code or Codex from your own editor. It runs on their machine with their setup, and they see who asked.
*S*sam> (sam via WeSesh asks) also log every 429 so we can spot abuse
### No agent starts from zero.
Agents share a room plan, short memory notes and direct messages. Nobody re-explains the codebase, and handoffs happen agent to agent.
### Your keys never leave your laptop.
Everyone uses their own AI account on their own computer. Credentials and terminals stay local. Only finished work is shared.
Features
## Built for building together
Live collaboration
### One workspace, on everyone's computer
Start a session and your project is copied to each teammate's machine, then kept in sync keystroke by keystroke. Everyone edits, runs and tests the same code locally, with their own tools, and sees each other's cursors as they type.
- Up to four people per room, across different networks
- VS Code and Cursor users in the same room
- Secrets, dependencies and build output are never shared
*A*
**alex's laptop** VS Code
**upload.ts**
*S*
**sam's laptop** Cursor
**upload.ts**
Independent agents
### Agents that work side by side, not over each other
Each agent claims the files it's changing and works in its own private copy, so nothing half-finished lands in your editor. Agents message each other for handoffs, and the room board shows what everyone's AI is doing.
- Claude Code and Codex connect on their own when you join
- A shared room plan decides who builds what
- Share your agent's activity, or keep it private
Safe merging
### Finished work merges itself. Collisions don't.
When an agent finishes, its work is published for everyone automatically. If two changes touch the same file, WeSesh merges them line by line. Only real overlaps wait for a person, and nothing is silently overwritten.
- Three-way merges for edits that don't collide
- Review any agent's change as a normal diff
- Turn auto-merge off to approve every change yourself
Both alex and sam changed line 12. Everything else merged on its own.
How it works
## Up and running in three steps
1.
Open your project, click WeSesh in the sidebar, then **Start a session** . Your files are shared and an invite link is copied for you.
2.
Send the link. Teammates open it in VS Code or Cursor, join from their own clone or a fresh folder, and their agents connect on their own.
3.
Edit side by side, prompt each other's agents, and watch finished work merge in for everyone.
FAQ
## Questions, answered
## Which editors does WeSesh work with?
VS Code and Cursor. People on either editor can join the same room, so you don't need to agree on one.
## Which AI agents are supported?
Claude Code and Codex. If they're installed, they connect to the room on their own as soon as you start or join one. Support for Cursor's agent is experimental. Each person can use a different agent.
## Do I have to share my AI account or API keys?
No. Everyone uses their own account on their own computer. Your credentials, terminals and agent sign-ins stay local. WeSesh doesn't share terminals and never runs commands on someone else's machine.
## Can my teammate's prompt run my agent without me knowing?
Prompts from a teammate go into the agent terminal WeSesh opened for you, labeled with who sent them, and you get a notification. You can turn friend prompts off at any time, and you can keep your agent's conversation private.
## What gets shared, and what stays private?
Text files in the folder you open. Hidden files like .env, anything in your .gitignore, node_modules, build output, binaries and large files are left out. Keep secrets out of your source files as you normally would.
## What happens when two agents edit the same file?
Each agent works in its own private copy and claims the files it's changing. When work finishes, changes to different lines are merged automatically. If two changes touch the same lines, the overlap waits in Pending Changes for a person to decide.
## How many people can join, and do we need the same network?
Up to four people per room, and you can be on different networks. A local-network mode is also available if you'd rather keep everything on your own network.
## Does it work with a project I already have cloned?
Yes. A friend can join from their existing clone. Matching files are left alone, differences stay as their local changes, and .git and node_modules are never touched.