Multi-User Collaboration

ClaudusBridge lets the AI agent and you join the same Unreal Multi-User (Concert) session as two separate participants. The agent gets its own desktop presence avatar in the level, just like a second person on your team would — so you can watch where it is working, and it can see where you are.

This is powered by the UClaudusBridgeMultiUserToolset, a set of roughly a dozen AICallable tools that the agent drives through the bridge. None of it requires a fork of the Multi-User app: the toolset reuses the existing Concert client that Unreal's Multi-User plugin already creates at editor startup, and ClaudusBridge auto-configures that client for you.

How it works

• One client, reused. The Multi-User plugin creates a Concert client (role "MultiUser") when the editor starts. ClaudusBridge declares MultiUserClient as a dependency and configures it at startup — it never spins up a second client.
• Presence avatars are native. The avatar/presence system lives in Unreal's own ConcertSyncClient library (IConcertClientPresenceManager plus the DesktopPresence content). ClaudusBridge links that directly, so the agent's floating "camera puck" avatar is the same presence system a human teammate uses. The avatar tracks the active viewport, so you can see where the agent is looking.
• Two participants, one session. The agent and the human each run their own editor, each connects the reused client to the same session, and each overrides its own display name and avatar color at runtime. The result is two distinct named participants in the Multi-User Browser.
• Strictly non-blocking. Concert discovery and connection are driven by the game-thread tick. Blocking the game thread on a connection future would deadlock the editor, so every tool initiates a request and returns immediately. The agent then polls GetConnectionStatus, ListServers, ListSessions, or ListParticipants to observe the result. The first call to a discovery tool typically returns an empty list — calling again a moment later returns the resolved data.

The toolset

All tools return JSON. They live under the ClaudusBridge|MultiUser category and are exposed to the agent through the standard tool-search flow (list_toolsets / describe_toolset / call_tool) or eagerly if you run the server in eager mode.

Tool	What it does
GetConnectionStatus	Reports the local client state: connected, server, session, displayName.
ListServers	Lists discovered Multi-User servers. Starts discovery if needed; first call may be empty.
ListSessions	Lists live sessions on a server (async cache; empty on first call, refreshed for the next).
CreateSession	Creates and connects to a new session on a server. Non-blocking — poll status.
JoinSession	Joins an existing session by name (resolves the name to an id via async query, then joins).
LeaveSession	Disconnects from the current session.
SetLocalIdentity	Overrides this editor's presence display name and avatar color (RGB 0..1) at runtime.
EnablePresence	Shows or hides this editor's desktop presence avatar for the other participants.
ListParticipants	Lists everyone in the session (local client plus peers), with display name, color, and isLocal.
LaunchAgentEditor	Boots a second, headless agent editor on its own MCP port and auto-connects it.
StopAgentEditor	Terminates the headless agent editor previously launched by LaunchAgentEditor.

Why SetLocalIdentity exists

The auto-configured avatar color is a single shared default. So that each editor instance shows up distinctly, each one calls SetLocalIdentity to override its own name and color after connecting. For example, the agent identifies itself as Claudus in orange (1.0, 0.45, 0.1).

Setting it up

You can drive a collaboration entirely from the agent side, or wire it up manually. The simplest reliable pattern uses two editors.

Option A — one human editor + one headless agent editor

1. Open the shared map on the human side first, so the presence avatars co-render and any synced content appears. (Use the Level toolset's OpenLevel, or just open it in the editor normally.)
2. From the human's editor, have the agent call LaunchAgentEditor. This boots a second, headless editor (-ClaudusBridgeAgent) on its own MCP port — which must differ from the human editor's port (defaults to 3001). The headless agent opens the map, launches or connects to the Multi-User server, creates-or-joins the session, sets its identity, and enables its presence avatar — all by itself.
3. The human auto-joins the session, or calls JoinSession to join explicitly.
4. Call StopAgentEditor when you're done to terminate the headless editor and free its resources.

LaunchAgentEditor is idempotent: if an agent editor it previously launched is still running, it is reused rather than duplicated.

Option B — two interactive editors, manual connect

1. Launch two editors. Give them different MCP ports with -ClaudusBridgePort=N (e.g. 3000 and 3001).
2. On the host editor, have the agent call CreateSession (empty ServerName/SessionName uses the configured defaults).
3. On the second editor, call JoinSession with the same session name.
4. On each editor, call SetLocalIdentity to give it a distinct name and color, then EnablePresence(true).
5. Poll ListParticipants until both show up.

Auto-connect on startup

ClaudusBridge can connect the agent to Multi-User automatically when the editor starts. This is governed by the Multi-User settings on UClaudusBridgeSettings, including:

• bMultiUserAutoConnectOnStartup — connect the reused client on launch.
• bMultiUserAutoLaunchServer — launch a local UnrealMultiUserServer if one isn't already running.
• MultiUserServerName / MultiUserSessionName — the default server and session names used when a tool is called with empty arguments.

When auto-connect runs, it discovers the server (launching one locally if allowed), creates-or-joins the configured session, applies the agent's identity, and enables presence — the same end state you'd reach by calling the tools by hand.

Tips and gotchas

• Different ports per editor. Two editors on the same machine must use different -ClaudusBridgePort= values, or the second MCP server can't bind.
• Open the same map on both sides. Presence avatars only co-render when both participants are in the same level.
• Discovery is async — poll, don't wait. Expect the first ListServers / ListSessions call to be empty. Call again shortly after.
• Saving while in a session is sandboxed. Concert sandboxes package saves inside a Multi-User session. Save reusable assets from a non-session editor instead.
• A server must exist. Either let bMultiUserAutoLaunchServer start a local UnrealMultiUserServer, or point the tools at an external one via MultiUserServerName.