Multiplayer cloud workstations for coding agents and humans

Provision VMs on any cloud or computer, load them with your favorite agent(s), and then remote control the agents from any chat surface, app, or API.

amika.dev

Sign up | Docs | Discord | Axioms

Amika lets you provision VMs on any cloud or computer, load them with your favorite agent(s) and your git repos, and then remote control the agents from any chat surface or app.

Each VM is configured as an Amika Rig, a workstation tuned for coding agents and humans to collaborate in.

• Run anywhere. Create Rigs on Kubernetes nodes, sandbox clouds (E2B, Daytona, Vercel, etc.), or (soon) your own computer.
• Bring any agent. Use Codex, Claude, OpenCode, Pi, or your own agent with existing subscriptions and API keys.
• Control from anywhere. Use chat apps, the web UI, API, CLI, SSH, or an app like Cursor or the Codex app

On a Rig, you can

• run 1 or more agents simultaneously
• expose the HTTPS URLs of the apps your agent is working on
• let Rigs and their agents communicate with each other
• programmatically control the Rig and its agents
• connect to the Rig from tools like the Codex app, Cursor, and cmux

Each Rig can be short-lived or persistent, depending on whether you want it to disappear when your PR is done, or whether you want to keep it around more permanently.

Amika automatically wires your Git repos and agent configs and credentials into each Rig.

Since Amika schedules cloud VMs and then gives you networking, agent messaging, and chat UIs, you can use it in many ways. Some examples:

• create multiplayer cloud devboxes for engineers that are pre-configured with your tech stack
• build managed cloud agents that you control via API to automate work in the background
• plug into your GitHub CI to not only run unit tests, but *auto-fix failures
• make custom agents for non-technical teammates to chat with on the web
• talk with agents from other tools like Slack and Linear

You can use Amika for anything where you need cloud VMs and control over the VMs, their agents, and their file contents or git repos.

To get started with Amika's cloud product:

1. Sign up at https://app.amika.dev/signup and follow onboarding.

2. Download the CLI

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

3. Login, and sync your Claude and/or Codex credentials

   amika auth login
   amika secret codex push --type oauth --name codex-oauth
   amika secret claude push --type oauth --name claude-oauth

Now, you can either (a) create a Rig and then connect to it however you choose, or (b) directly start an agent chat session, which will provision its own Rig behind the scenes. Both can be done from the https://app.amika.dev/, and also from the CLI.

If you want to create a Rig and then chat with it from Codex, Cursor, OpenCode, SSH, etc., you can create a Rig without first making an agent session.

Assuming you connected GitHub during web onboarding:

# make sure you uploaded an SSH key
amika secret ssh-keygen

cd path/to/git/repo/you/want/to/work/on
amika rig create --name my-first-rig
amika rig ssh my-first-rig

This spins up a Rig, pre-loaded with your Git repo and agent credentials. List your Rigs with:

amika rig list

cd path/to/git/repo/you/want/to/work/on
amika send --agent codex "What does this repo do?"

This will spin up a Rig in the background and send the message to a Codex agent on the Rig. You can list agent sessions with:

amika session list

If you want to self-host, read the self-hosting guide.

Usually, each Rig boots from a repo, which specifies the config for the Rig (VM size, git repos loaded, agent skills, MCP servers, config files loaded). You define config-as-code inside a repo's .amika/config.toml, but you can also configure settings in the web UI or adhoc per Rig. See more docs on how configuration works.

Our goal is to make cloud agents and VMs feel like you're just using your desktop, but with extra super-powers:

• multiplayer: multiple humans and agents can share the same Rig and chat sessions
• programmatic control + human-in-the-loop: you must be able to toggle between (a) programmatic or agentic control of the Rigs and agents, and (b) human-in-the-loop UIs
• multi-surface: talk to agents from (a) work tools like Slack and Linear, (b) the web UI, API, CLI + SSH, and (c) your preferred editors and ADEs like Cursor and the Codex app
• run any harness, any model, any ADE: everybody has their favorite harness, models, and agent development environments; an Amika Rig doesn't restrict you to just one
• run on any computer or cloud: You should be able to slice any computer up into Rig workstations — the desktop in your closet, a Rig on E2B, a node in your Kubernetes cluster
• config-as-code: your Rig configuration and agent workflows are just code in a git repo; you can pick which config to use per Rig, with per-user config customization

See more of our axioms about the type of workstation agents need, and what a new "operating system" for agents should look like.

Amika is kind of like an "operating system" for AI agents. We have a few important parts:

• a VM networking and agent messaging layer
• a VM scheduling layer
• the control plane that manages these
• the UIs and interfaces to work with the agents and Rigs

Compared to agents and agent development environments (ADEs) like Claude, Codex, OpenCode, Conductor, cmux: we are not an agent or a harness. We are an environment and cloud workstation for humans and agents. You can connect to an Amika Rig and its agents using these other tools. In some ways, you can think of us like an "operating system" for AI agents.

Compared to sandbox cloud providers like E2B, Daytona, Modal, Sail Research: we are a networked runtime and "operating system" on top of any cloud or computer. We schedule VM workstations on any compute provider, tune it to be a great agent workstation, and turn the Rig workstation into an agent mesh network to connect the Rigs and agents together.

• amika: CLI to interact with Amika
• amikad: daemon that runs inside each VM or machine; manages Rig setup, network connectivity, and communication with the amika-gateway and the e2e-encrypted amika-relay
• sandbox-image: Rig VM snapshots + images. Defines the Rig environment for the agents (docs)
• amika-sdks: Typescript SDK to interact with Amika

• amika-control-plane: control plane that schedules Rigs and stores references to all Rigs
• amika-ui: web UI for interacting with Amika agents and Rigs
• amika-relay: handles fully e2e encrypted...
  • messages to agents
  • exec commands to Rigs
  • network and SSH access

• amika-gateway: gateway inside your cloud that receives signed or encrypted commands, decrypts them, runs auth checks, and sends them to the right Rig or agent
  • sandbox-provisioner: the adapter layer that converts gateway Rig commands to the right format per provider (ie E2B, K8S, Modal, Daytona, etc.)

Other tools:

• amikalog: capture your Claude Code and Codex sessions, alongside the git repo changes
• amika-hostd: run Rigs on your own machine as smolvm VMs, registered with Amika. Install it, with Node.js and smolvm if missing, using curl -fsSL https://raw.githubusercontent.com/gofixpoint/amika/main/install-amika-hostd.sh | sh
• amikalyze: experimental guardrails that control which files coding agents can modify
• akfs: experimental tooling for treating file contents as structured data that humans and AI agents can work with
• js/sandbox: Typescript package for plugging sandbox providers into Amika

Links:

• amika.dev: cloud service
• docs.amika.dev: docs

See CONTRIBUTING.md for development setup and guidelines.

Apache 2.0