AQ vs Amika: build the factory, or move into the workspace

Published September 22, 2026 · by the AQ team

How is AQ different from Amika? Amika (amika.dev, by Fixpoint, Inc., a Y Combinator-backed company) is "multiplayer cloud workstations for coding agents and humans": infrastructure for provisioning VMs it calls Rigs, on its hosted cloud, on Kubernetes, on sandbox clouds, or soon on your own machines, loading them with coding agents, and remote controlling those agents from the web, Slack, Linear, SSH, CLI, API, Codex, or Cursor. AQ is a finished team workspace: agents run as real CLIs on an always-on machine, and the live terminal, code editor, dev-server preview, and resulting PR are the product, opened in every teammate's browser. The cleanest way to put it: Amika hands your team the parts to assemble its own software factory; AQ is the workspace your team moves into. Both are serious multiplayer bets, aimed at different buyers.

Amika is moving fast (it showed Rigs on Hacker News in mid-September 2026), so every Amika claim below is as of September 2026, verified against amika.dev, the open-source repository at github.com/gofixpoint/amika, and its Y Combinator company and launch pages. One disambiguation up front: Amika here means the developer platform by Fixpoint, Inc. (YC Fall 2025, founded by Dylan Mikus and Jakub Cichon), not the haircare brand that shares the name.

AQ vs Amika at a glance

What is Amika?

Amika is Fixpoint, Inc.'s pivot into agent infrastructure, and its self-description is precise: provision VMs on any cloud or computer, load them with your favorite agents, then remote control the agents from any chat surface, app, or API. Each VM is configured as a Rig, "a workstation tuned for coding agents and humans": it can run several agents at once, expose HTTPS URLs for the apps inside it, talk to other Rigs, and be driven programmatically. Rigs boot in seconds from snapshots with repositories, development services, and agent CLIs already in place, and a Rig can live as a persistent dev box, disappear after one task, or be cloned when work branches. The company's YC profile pitches it as sandboxed AI coding agents in the cloud, "the same infrastructure Ramp, Coinbase, and Stripe built in-house."

Two things stand out. First, the multiplayer claims are real, not bolted on: teammates can be invited into the same Rig, inspect a live preview URL of what an agent changed, share agent chat sessions, and take over work. That puts Amika in the small group of tools sharing the session itself rather than its artifacts. Second, the architecture is open at the edges: the CLI, the amikad daemon, the sandbox images, and the TypeScript SDKs are Apache 2.0 on GitHub, with a self-hosting guide, while the control plane, web UI, and encrypted relay stay closed. Installation, as of September 2026, is a one-line script:

curl -fsSL https://raw.githubusercontent.com/gofixpoint/amika/main/install.sh | sh
amika auth login

The YC launch framing calls Amika "the operating system for AI agents to write and verify code," and that is the right mental model: an OS layer of VM provisioning, networking, snapshots, and remote control that you and your agents build on. Its founder has argued publicly that cloud coding agents should reuse persistent VMs between pull requests instead of rebuilding a clean environment every time, and Rigs are that argument shipped. We could not verify published pricing for the hosted platform 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 on your own subscriptions. 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 Amika stands out

• It is infrastructure, and proud of it. If your platform team wants to design its own agent execution layer (choose the cloud, wire Rigs together, script everything over an API and SDK), Amika gives you the primitives instead of a finished opinion. The YC tagline says it plainly: infra to build your own software factory.
• Snapshots and clones as first-class moves. Rigs boot in seconds from snapshots with repos, dev services, and agents pre-configured, and a Rig can be cloned when work needs to branch. Environment reuse between pull requests is the founding argument.
• Runs on more substrates. Hosted, Kubernetes, sandbox clouds like E2B, Daytona, and Vercel, and soon your own hardware ("even the desktop in your closet"). Teams with strong infrastructure opinions have room to exercise them.
• An open core you can read. The CLI, daemon, images, and SDKs are Apache 2.0 with a self-hosting guide, which is more source than most tools in this space publish.
• Rig-to-Rig communication and programmatic control make agent-driven pipelines a supported pattern rather than a hack.

Where AQ wins

• The workspace is finished, not a kit. On AQ the live terminal, editor, preview, and PR tracking are already assembled around each unit of work. Nobody provisions, wires, or scripts anything to get a team watching an agent work; you open the workspace in a browser.
• Isolation by construction, in git. Every workspace gets its own git worktree and branch, so parallel agents never collide and every run is reviewable and revertable as ordinary git history, not as VM state.
• Delegated control with a clear owner. Teammates watch the same live session, and typing into someone else's terminal happens only after the owner approves a control request in one click; the owner keeps their own input. Handoff has manners.
• Team plumbing included. Per-user GitHub auth, per-user CLI logins on your own Claude and OpenAI accounts with no markup, PRs tracked per workspace, owner-managed workspace visibility (team-visible, or private and shared with specific people), preview comments that become agent prompts, and Linear intake with two-way status sync and ownership that follows the assignee.
• Nothing to install to evaluate. Amika starts at a curl-piped install script and an auth login; AQ's Free sandbox is a private machine in an isolated network with nothing to install, no time limit, in the browser on macOS, Windows, Linux, and mobile.

The deeper difference: who assembles the factory

This is the closest positioning collision in the category so far. Both products believe agent-assisted development should be multiplayer, both share the live session rather than just its artifacts, and both run agents on machines that outlive a laptop. The evidence that this matters keeps piling up: 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. Single-player agent workflows are the default that both companies exist to break.

The split is who does the assembly. Amika's buyer is a team that wants to own its execution layer: pick the substrate, define the Rigs, snapshot the golden environment, script the orchestration over the SDK, and build the factory that fits. That is genuinely powerful, and it is also a project; the factory is yours to design, operate, and debug. AQ's buyer wants the outcome without the project: a workspace per task, an isolated worktree per workspace, the team inside the same live session, a preview link for anyone who needs to see the change, and the PR at the end. It is the same fault line as AQ vs Tutti VM (sync layer versus shared machine) and AQ vs Mosaic (shared memory versus shared machine), one level up: given that the machine should be shared and durable, do you buy the parts or the place?

Pricing compared

Amika, as of September 2026: the CLI, daemon, images, and SDKs are open source under Apache 2.0, and we could not verify published pricing for the hosted platform.

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 on your own subscriptions.

Bottom line

Amika is the most credible infrastructure play yet for multiplayer agent execution: real VMs on the substrate of your choice, snapshots and clones, an open core, and remote control from anywhere your team already talks. If your platform team wants to design its own agent factory, it is the strongest kit on the table. AQ starts where the kit ends: the factory is already assembled into a multiplayer workspace, agents run as the real CLIs your engineers already pay for, every workspace is an isolated worktree ending in a reviewable PR, and the whole team can watch and steer the live session from a browser with nothing to operate. Build the factory, or move into the workspace that is already running.