/ comparisons

Multiplayer AI platforms compared: Agent Swarm, Claude Tag, Dust, QM, Superconductor, Viktor

Checked on 2026-10-13.

The short answer

Pick a hosted teammate — Claude Tag, Dust, or Viktor — if you want shared AI in Slack or Teams today and someone else to run the infrastructure. Pick a self-hosted multiplayer system — QM or Agent Swarm — when where your data, credentials and accumulated context live matters more than setup speed: QM for an isolated agent workspace per person and room, Agent Swarm for one coordinated team of specialists. Superconductor sits between: cloud compute for coding agents, the whole team inside every session.

How we compared

We scored all six against the same eight-point rubric:

Shared sessions — can several people and agents share one space?
Shared context and memory — does what a session learns persist and travel?
Tools and integrations — what can it connect to and act on?
Deployment model — hosted, self-hosted, or both?
Permissions — who controls what agents may access and do?
Auditability — can you inspect what agents did later?
Human approvals — can work pause for a person before anything irreversible ships?
Practical limits — what each platform asks you to accept.

Every table cell carries one evidence label:

Documented — stated in the vendor's public docs or site, or in ours, linked below.
Tested — we ran it ourselves.
Vendor claim — marketing copy we could not verify.

The comparison

Rubric	Agent Swarm	Claude Tag	Dust	QM	Superconductor	Viktor
Shared sessions	Documented: one swarm shared via Slack, Linear, GitHub, task pool	Documented: one @Claude per Slack channel; anyone can tag and pick up the thread	Documented: shared workspace agents; people steer together	Documented: personal scopes and shared rooms, in Slack and web	Documented: every session open to the team; anyone can steer	Documented: one hosted assistant mentioned in Slack or Teams
Shared context / memory	Documented: per-agent identity files plus shared semantic memory and task journals	Documented: channel context over time, scoped to admin-defined channels	Documented: knowledge from 70+ connectors, shared across agents	Documented: memory, files, permissions scoped per person or room	Documented: shared workspace for tickets, credentials, sandboxes	Documented: persistent context inside Viktor's cloud
Tools and integrations	Documented: GitHub, GitLab, Slack, Linear, Jira, Sentry, email, WhatsApp, MCP	Documented: tools, data and codebases admins grant	Documented: 70+ connectors — Notion, Google Drive, Slack, Salesforce, Zendesk	Documented: notes, email, docs, databases; repo work with PRs and CI	Documented: deep GitHub, Slack, Linear; Playwright; MCP, skills	Documented: 3,200+ integrations across CRM, docs, ads, finance
Deployment model	Documented: self-hosted Docker Compose (Helm, Podman), MIT, or managed cloud	Documented: hosted by Anthropic; beta for Claude Enterprise and Team	Documented: hosted SaaS, EU or US regional hosting	Documented: org-owned deployment to your Fly.io or AWS account	Documented: cloud workspaces on AWS; enterprise sandboxes in your own cloud	Documented: hosted SaaS
Permissions	Documented: per-agent tool allowlists, lead-only operations, credential broker	Documented: admins define channel-scoped identities, tools, data access	Documented: user/builder/admin roles, private spaces, SSO, model tiers	Documented: Strict/Auto/Dangerous postures, command policy	Documented: RBAC (Owner, Admin, Collaborator, Viewer); network sandboxing	Documented: admin controls; credentials never touch the AI
Auditability	Documented: task, session, command logs in your database; OTel export	Documented: admins see a log of everything @Claude did and who asked	Documented: admin audit logs plus usage and cost analytics	Documented: audit is part of the security model	Documented: per-run artifacts — screenshots, videos, diffs by agent	Vendor claim: in-product activity views; no org-level audit log documented
Human approvals	Documented: HITL gates pause for Slack approval; reviewers challenge results	Documented: no gates documented; admins cap token spend	Documented: human review built into workflows	Documented: command policy and postures gate risky commands	Documented: users must review all AI code before production	Documented: sensitive actions wait for approval
Practical limits	Documented: you run and maintain the containers; heavier setup	Documented: Slack-first, one model (Opus 4.8), Enterprise/Team beta	Documented: hosted only; no self-hosting in their docs	Documented: you operate the deployment and Postgres; scopes isolated by design	Documented: code runs on their infra unless enterprise brings its own cloud	Documented: closed hosted product; model choice abstracted away

The six platforms

Agent Swarm

Agent Swarm is an MIT-licensed, self-hosted multi-agent operating system for software work: a lead agent decomposes outcomes and routes them to specialized workers — coders, reviewers, researchers — sharing one task system, dependencies, memory and review loops. Its strength is ownership: journals, logs, credentials and memory live in your infrastructure, the harness and model are swappable per worker, and HITL gates plus reviewer agents keep consequential work honest. Its limits are the flip side of self-hosting: you run the containers, hold the model keys, and wiring a lead, workers and integrations is real work. See the docs and why accumulation beats access.

Claude Tag

Claude Tag is Anthropic's persistent Slack agent: one @Claude per channel that anyone can tag, that builds context from the channels it lives in, and that works asynchronously — Claude Code evolving into a team teammate. Strengths: zero infrastructure, channel-scoped memory and identities set by admins, token spend caps, asynchronous tasks that run for hours, and an activity log of who asked for what. Limits: Slack-first, in beta for Claude Enterprise and Team customers, one vendor's model (Opus 4.8), and no approval gate documented — governance is spend caps and logs, not pauses. Head-to-head: Claude Tag vs Agent Swarm.

Dust

Dust is a hosted platform for building, sharing and running agents with company context: 70+ connectors bring Slack, Notion, Google Drive, GitHub, Salesforce and Zendesk into one workspace; 20+ models from OpenAI, Anthropic, Google and Mistral power the agents. Strengths: breadth of context, roles and private spaces, EU or US hosting, no-training and zero-retention guarantees, admin audit logs. Limits: hosted only — no self-hosted deployment appears in their docs — and it optimizes for knowledge and cross-functional work, not deep software delivery. It is the strongest fit for governed, company-wide AI answers. For the idea underneath all these tools, see shared context for AI agents.

QM

QM is Y Combinator's MIT-licensed multiplayer agent harness: each person and shared room gets a durable, isolated agent workspace — memory, files, permissions, cron jobs, sandbox — administered as one org-owned deployment on your Fly.io or AWS account. Strengths: honest ownership (your cloud, policies, credentials), harness choice (Pi, OpenCode, Codex and Claude Code on one core), explicit security postures with a mandatory command policy, and Slack and web surfaces backed by durable computers that keep files, sessions and background work alive between turns. Its limit is deliberate: isolation between scopes leaves cross-scope coordination to humans. Head-to-head: QM vs Agent Swarm.

Superconductor

Superconductor is a cloud workspace for teams and coding agents: run Claude Code, Codex, Amp, Cursor, Grok, Pi, OpenCode and more in isolated cloud containers, with every session open to the whole team — anyone can jump in, take the wheel mid-run, or ask the agent about a landed PR directly. Strengths: shared sessions taken furthest (live previews, QA checks, guided review, per-run screenshots and videos grouped by agent), bring-your-own model plans or keys, network sandboxing and role-based access. Limits: code and credentials run on their infrastructure unless the enterprise plan puts sandboxes in your own cloud, and there is no self-hosted deployment.

Viktor

Viktor is a hosted AI employee for Slack and Microsoft Teams: a broad assistant connecting to 3,200+ tools across CRM, docs, ads and finance, handling mixed business work — reports, dashboards, follow-ups, support tickets, and light code alongside its PR-review abilities. Strengths: breadth and speed-to-value; sensitive actions wait for a person's approval, credentials never touch the AI, and their security page documents SOC 2 Type 1 and GDPR alignment. Limits: a closed, hosted product — model choice hidden, the runtime not yours to inspect — and engineering depth is not the center of gravity. Head-to-head: Viktor vs Agent Swarm.

Where Agent Swarm is the wrong choice

Honesty first — this page is only useful if it is fair:

You do not want to run anything. The open-source path means containers, volumes, secrets and backups are yours to operate.
Setup effort decides. A hosted teammate is live in minutes; a swarm needs a lead, workers, credentials and integrations wired first.
Your work is broad business operations. For ads, reports, CRM follow-ups and support across dozens of SaaS tools, Viktor or Dust cover more surface out of the box.
You want one assistant per person, not a team. If people mainly need a private agent workspace, QM's per-scope model fits better than a coordinated swarm.

How to choose

Zero infrastructure, Slack-first, one vendor's deepest model → Claude Tag.
Company knowledge and cross-functional work across many SaaS tools, hosted → Dust.
One broad AI employee across the business stack → Viktor.
A durable, isolated agent workspace per person and room, on your cloud account → QM.
A team that lives inside coding sessions and wants shared steering in the cloud → Superconductor.
A coordinated team of specialist agents you host yourself, with memory, approvals and audit trail inside your perimeter → Agent Swarm.

None of these is exclusive — a hosted assistant for company-wide questions can coexist with a swarm owning the engineering loop. For pairwise comparisons, see /vs.

FAQ

What is a multiplayer AI platform?

A platform where more than one person — and often more than one agent — shares the same working context: one assistant per channel (Claude Tag), shared agents and knowledge (Dust, Viktor), per-person workspaces (QM), team-wide coding sessions (Superconductor), or a coordinated agent organization (Agent Swarm). The alternative is a single-user chat window where nothing compounds.

Can Agent Swarm run alongside Claude Tag or Dust?

Yes. They overlap but do not conflict. A hosted assistant can answer company-wide questions while a self-hosted swarm owns the deeper engineering loops — implementation, review, recurring repo checks — with memory, credentials and logs inside your infrastructure.

Which of these can we self-host?

Agent Swarm (MIT; Docker Compose, Helm, rootless Podman) and QM (MIT except where noted; your own Fly.io or AWS account). The other four are hosted; Superconductor's enterprise plan puts agent sandboxes in your own cloud as the partial exception.

Sources

Agent Swarm docs — https://docs.agent-swarm.dev (collaboration, memory, integrations, deployment, HITL gates)
Agent Swarm source — https://github.com/desplega-ai/agent-swarm (MIT)
Anthropic, "Introducing Claude Tag" — https://www.anthropic.com/news/introducing-claude-tag
Dust — https://dust.tt, https://docs.dust.tt, https://dust.tt/security (connectors, roles, model tiers, hosting, retention)
QM — https://qm.ycombinator.com, https://github.com/yc-software/qm (scopes, postures, deployment, MIT)
Superconductor — https://superconductor.com, https://superconductor.com/pricing, https://superconductor.com/docs/security (sessions, sandboxes, RBAC, review rule)
Viktor — https://viktor.com, https://viktor.com/integrations, https://viktor.com/security (tools, approvals, SOC 2 Type 1)