AQ vs Mosaic: shared memory, or the shared machine

Published September 15, 2026 · by the AQ team

How is AQ different from Mosaic? Mosaic (mosaic.inc, YC S26) syncs every AI coding session your team runs (Claude Code, Codex, Cursor and more) into one shared place any agent can read, so the next session or the next teammate starts with the context of everything that came before. The agents themselves keep running wherever they already run, usually each person's own laptop. AQ shares the running session itself: agents run on an always-on machine in your own cloud, and the whole team opens the same live terminal in the browser, watching and steering the work as it happens. Mosaic makes what agents did portable; AQ makes what agents are doing a shared place. Both call themselves multiplayer, and they mean different layers of the same problem.

Mosaic launched publicly in 2026 and is moving fast, so every Mosaic claim below is as of September 2026, verified against Mosaic's own site (mosaic.inc), its YC launch page, and its YC company page. One disambiguation up front: Mosaic here means the YC Summer 2026 company whose tagline is "defining the frontier of multiplayer AI." It is unrelated to the several other developer tools and companies that share the name.

AQ vs Mosaic at a glance

What is Mosaic?

Mosaic is a YC Summer 2026 company building what it calls multiplayer infrastructure for people and AI agents. The shipping product is shared memory: Mosaic syncs every AI coding session your team runs, across Claude Code, Codex, Cursor and more, into one shared place that any agent can use. Its launch framing names the problem precisely: every coding agent session starts from zero, with no memory of what happened last session, why a decision was made, or where the last person stopped. Git commits record the outcome; the investigation that produced it evaporates in a private transcript on someone's laptop.

The architectural bet is quotable. Most multi-agent systems copy the human org chart, specialized agents passing messages to each other. Mosaic argues that structure only exists because humans cannot share memory, and that the real unit is not the agent but one shared context store every agent reads from and writes to. Ocean is that store: Mosaic's shared-memory layer, described on its site as putting everyone's AI coding sessions into one shared, read-only drive, so a teammate's agent can pick up exactly where another session left off instead of rediscovering it.

Practically, as of September 2026, installation is macOS-first via Homebrew:

brew install emergent-inc/tap/mosaic
mosaic install

Sessions sync once the tool is installed, and the YC launch page reports about 2,000 installs and 37 organizations actively syncing (company-reported figures). Mosaic also says it began as a real-time coding environment where multiple people and their agents work together, before centering on the memory layer, and credits that arc with helping define the multiplayer AI category. We could not verify published pricing for the product as of September 2026.

What is AQ?

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud.

On AQ the agents are the real CLIs your engineers already use (Claude Code, Codex, Cursor Agent, Kimi, Grok, or plain shells), running in persistent tmux sessions on the team's VM and streamed live to the browser. Each engineer signs in with their own Claude or OpenAI account, and AQ never marks up usage. Every workspace gets one isolated git worktree (branch ai/{id}-{slug}, automatic dependency install, one-click rebase onto main), so parallel sessions never collide. Sessions survive a closed laptop and resume from any device, including a phone. Teammates open the same workspace and watch the same live session; typing into someone else's terminal is delegated by its owner approving a control request in one click, and the owner keeps their own input. Each workspace runs a live dev-server preview with shareable links that work without an account for viewing, and pinned comments on the preview can be sent to the agent as prompts. Label a Linear issue ai-task and a workspace appears; humans start agents, never auto-launched. There is no shared multi-tenant execution tier.

Where Mosaic stands out

• It attacks the memory problem directly. Cross-session, cross-agent, cross-teammate context is a real tax, and Mosaic is purpose-built for it. AQ preserves the live session and its scrollback; Mosaic turns the whole team's session history into something the next agent can query.
• It rides on whatever you already run. No new place to work: engineers keep their exact local setup, and Mosaic syncs the sessions those tools produce. Its site lists Claude Code, Codex, Cursor and more than a dozen agents and IDEs as of September 2026.
• Agent-readable, not just human-readable. The point of Ocean is that agents consume it. A teammate's agent starting a task can draw on what every earlier session tried, without a human writing a handoff doc.
• A crisp thesis. One shared context store instead of message-passing between siloed agents is a genuinely interesting position in the multi-agent debate, and Mosaic states it plainly.

Where AQ wins

• The session itself is shared, live. Mosaic shares the record of a session; AQ shares the session. Teammates watch the same terminal keystroke for keystroke, catch a wrong turn while it is happening, and steer mid-run instead of reading about it afterward. That is the difference between sharing a Claude Code session with your team and sharing its transcript.
• The machine outlives the laptop. On Mosaic's model the agent still runs on someone's machine, and stops when that machine sleeps; the memory persists, the work does not. On AQ the agent runs on an always-on VM, so the session started at 6pm is still running at midnight and resumable from a phone at 7am.
• One environment, not N. Everyone works against the same VM: same dependencies, same running dev server, same preview link. Synced memory does not stop two laptops from disagreeing about a Node version.
• Isolation by construction. Each workspace gets its own git worktree and branch, so parallel agents never collide and every run is reviewable as ordinary git history.
• Team plumbing included. Per-user GitHub auth, PRs tracked per workspace, Linear intake with two-way status sync, owner-managed workspace visibility (team-visible, or private and shared with specific people), and preview links outside reviewers can comment on after a quick email sign-in.
• Nothing to install to evaluate. Mosaic is a macOS Homebrew install as of September 2026; AQ is browser-based on macOS, Windows, Linux, and mobile, and the Free sandbox requires no install at all.

The deeper difference: the record of the work vs the work

Mosaic and AQ agree on the diagnosis. Agent-assisted development is single-player by default, and the evidence says so: a July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. Both products exist to break that isolation, and both push the industry toward multiplayer agents.

They break it at different layers. Mosaic makes the team's agent history collective while leaving execution personal: your laptop runs your agent, and Ocean carries what it learned to everyone else. AQ makes execution itself collective: the team's VM runs the agents, and the browser is a window onto the same live machine. The two are not even mutually exclusive in principle, since a memory layer syncs sessions wherever they run. But they answer different failure modes. If your pain is agents rediscovering what a teammate's agent already learned last Tuesday, that is the memory problem, and syncing history addresses it (so does keeping agents in shared, resumable workspaces; carrying context between Claude Code and Codex covers the manual patterns). If your pain is that nobody can see the agent working, the session dies with a laptop lid, and handoff means re-running everything, that is an execution problem, and no amount of memory fixes it. This is the same fault line as AQ vs Tutti VM, another rival that syncs state across personal machines rather than sharing one: where does the agent actually run, and who can be inside the session while it does?

Pricing compared

Mosaic, as of September 2026: install is free via Homebrew on macOS, and we could not verify published pricing for the product.

AQ has two plans. Free is a personal sandbox for one person: AQ creates a private machine in an isolated network, nothing to install, no time limit. Team is $50 per user per month early access (standard $200, billed monthly), covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM in its own isolated network, with your rate locked for your first 12 months. Inviting a teammate costs nothing until the person accepts and joins. Model usage rides each engineer's own Claude or OpenAI account: AQ never marks up usage.

Bottom line

Mosaic is one of the sharpest statements yet of the multiplayer AI thesis: the team, not the individual, should own what agents learn, and one shared memory beats a mesh of siloed agents passing messages. If your team's agents keep re-answering questions another session already settled, it is worth the Homebrew install. AQ's bet is one layer lower: before the record of the work, share the work. Agents on an always-on machine in your own cloud, sessions any teammate can open, watch, and steer live from a browser, one worktree per workspace so parallel runs never collide, and work that keeps going when every laptop is closed. Shared memory tells you what happened. A shared live session is where it happens.