Multiplayer & Social

Agor is great solo. Multiplayer is what makes it Figma.

Just as Figma turned design from a solo activity into real-time collaboration, Agor brings multiplayer presence to AI coding. No more “share your screen” calls or wondering what your teammate’s agent is doing.

👀 Live Cursors

See where your teammates are working in real time. Every user on a board has a cursor showing:

• Position on the canvas
• Name and avatar
• What they’re hovering or dragging

Cursors update every ~100ms, making collaboration feel fluid. Notice someone hovering over a session? Jump in. See them dragging a worktree to the same zone? Coordinate live instead of stepping on each other.

👥 Facepile

Know who’s online at a glance. The facepile shows all active users on the current board with their avatars and presence status. Same pattern Figma uses — you always know who’s in the room. No “are you looking at this?” pings on Slack.

💬 Spatial Comments

Annotate sessions, worktrees, zones, and boards with threaded conversations.

Leave scoped/spatial comments on:

• Board-level — Team discussions about workflow or priorities
• Zones — “All sessions in this zone need API keys configured”
• Worktrees — “Ready for review” or “Blocked on API access”
• Sessions — “This approach didn’t work, try the forked version”

Comments create a persistent conversation layer on top of your AI work:

• Thread replies for focused discussion
• @username mentions
• Direct links to specific sessions or worktrees
• Comment history with full timestamps
• Organized by scope in the comments panel (Board → Zones → Worktrees → Sessions)

The insight: AI conversations are ephemeral. Claude says something, you respond, it’s buried in the chat. Comments are spatial and persistent — pin them to the exact artifact (zone, worktree, session) where they matter. Teammates discover insights without digging through transcripts.

✨ Attention Pulse

Worktrees pulse teal when they need attention. Sessions ready for input, callbacks waiting to be reviewed, completed long-runs — the worktree card pulses on the board so you can pulse-watch from a peripheral browser tab.

Combined with the favicon status dots, you don’t have to keep your eye on Agor to know when something needs you.

🖥️ Multiplayer Terminal Sessions

Real-time shared terminals via tmux. When multiple users open the same worktree’s terminal, they see each other’s keystrokes live.

How it works

• Each worktree gets a dedicated tmux window in the shared agor session
• Multiple users connecting to the same worktree attach to the same window
• WebSocket broadcasting synchronizes keystrokes and output
• Works automatically when tmux is installed; no configuration

Use cases

• Pair programming — Two devs in sync on the same feature
• Live debugging — One person navigates while another observes
• Onboarding — Senior dev demos commands; junior follows along
• Code review — Reviewer explores the worktree interactively during review

Terminal sessions are worktree-scoped — users only see terminals for worktrees they’re actively using.

Privacy note: With unix_user_mode: simple (the default), the terminal runs as the daemon user and gives member+ users access to daemon-readable files (config, DB, JWT secret). Use insulated or strict mode in shared environments. See Security.

🌐 Real-Time Strategy for AI Teams

The combined effect of cursors + facepile + comments + zones + presence is something like an RTS for engineering work:

• Watch teammates and agents move across tasks live
• Cluster sessions, delegate, pivot, iterate together
• Drag a worktree across the board and the trigger fires for everyone watching

This is the part that’s hard to convey in a doc. Try it on a board with one other person and you’ll feel it.

⚙️ Per-User Settings

Multiplayer is more than presence — every user brings their own credentials, env, and tool config to the boards they share.

The settings panel is split into two surfaces:

Profile

• General — display name, avatar, email, role.
• Env Vars — encrypted environment variables, scoped Global (auto-injected into every session you own) or Session (only injected when you opt in per session under Session → Settings → Env Vars). Useful for GITHUB_TOKEN, HUBSPOT_API_KEY, vendor credentials, or anything you’d otherwise paste into a .env.
• Audio — chime / notification preferences for attention pulse and session events.
• Personal API Keys — issue tokens for scripting Agor itself (CLI / external tools).

Agentic Tools

• API Keys — model-provider keys (Anthropic, OpenAI, Google, etc.) used when a session selects you as the actor.
• Claude Code / Codex / Gemini / OpenCode — per-runtime config: default model, permission mode, extra arguments, OAuth login state. Each user authenticates the SDKs they actually use; no shared “agor-bot” credentials.

Why per-user matters in multiplayer

When teammates share a board, sessions still execute under a specific user’s identity:

• The session’s Anthropic / OpenAI key is the session creator’s key (billing follows usage).
• Env vars merge: gateway/channel → user globals → session-scoped — so a Slack-driven session run as you carries your GITHUB_TOKEN, not a shared bot token.
• In unix_user_mode: strict, the executor process literally runs as the user’s Unix account.

This is what makes co-locating teams on one Agor instance work without secret-sharing: everyone keeps their own credentials, but the boards, worktrees, and conversations are shared.

🔌 Connected MCP Servers (Per-User OAuth)

Bring your tools — Slack, Linear, GitHub, HubSpot, custom internal MCP servers — and let Claude / Codex / Gemini call them with your authority.

Agor speaks the full MCP transport matrix:

• stdio — local binaries (@modelcontextprotocol/server-filesystem, @modelcontextprotocol/server-github, etc.).
• sse / http — remote HTTP-based MCP servers, with header-based auth or OAuth 2.1.
• OAuth 2.1 with auto-discovery — Agor probes both OAuth 2.0 and OIDC discovery endpoints, completes the authorization code flow in-browser, and persists refresh tokens encrypted in the daemon database.

Per-user, not per-instance

Each user authenticates their own OAuth grant per MCP server. When a session attaches an OAuth-secured MCP server, Agor injects the acting user’s token — never another user’s. Token refresh is handled transparently; revocation is per-user, per-server. The UI surfaces auth state with a userAuthenticatedMcpServerIds set so you can see at a glance which servers you’re connected to.

This is how a shared Linear or Slack MCP server can sit on the team’s Agor instance and still respect each member’s individual permissions — your prompt against Linear runs with your Linear scope, your teammate’s runs with theirs.

Configuration scopes

Pairing with the Message Gateway: a Slack-routed session that runs as the matched Agor user, with that user’s OAuth-authenticated Linear MCP server attached, can take Linear actions under the human’s identity — no shared service account, full audit trail.

Related

• Boards & Zones — The spatial canvas itself
• Worktrees — The primary entity that pulses, gets commented on, and hosts terminals
• Rich Chat UX — Favicon dots, chimes, queued messages
• Agor MCP Server — The other side: Agor exposing itself as an MCP server to agents
• Message Gateway — How external messaging maps to Agor user identities
• Security — Trust boundaries for shared terminals and credentials