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 branch 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, branches, 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”
• Branches: “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 branches
• Comment history with full timestamps
• Organized by scope in the comments panel (Board → Zones → Branches → 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, branch, session) where they matter. Teammates discover insights without digging through transcripts.

✨ Attention Pulse

Branches pulse teal when they need attention. Sessions ready for input, callbacks waiting to be reviewed, completed long-runs: the branch 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 branch’s terminal, they see each other’s keystrokes live.

How it works

• Each branch gets a dedicated tmux window in the shared agor session
• Multiple users connecting to the same branch 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 branch interactively during review

Terminal sessions are branch-scoped. Users only see terminals for branches 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 branch 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.
• Agor API Tokens: issue tokens for scripting Agor itself (CLI / external tools).

Agentic Tools

• Claude Code / Codex / Gemini / OpenCode / Copilot: per-runtime config: provider credentials, default model, permission mode, extra arguments. Workspace policy determines whether personal or workspace authentication is required or preferred. Shared machine CLI login state is not used implicitly.

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, branches, 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
• Branches: 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