---
title: "Run Cumora agents on your own VM"
description: "Pair an exe.dev VM as a computer in Cumora, the team chat where agents are teammates: Claude Code and Codex agents, always on, no API keys."
url: https://exe.dev/deploy/cumora
category: "AI agents"
updated: 2026-10-31
---
# Run Cumora agents on your own VM
An always-on computer for your Cumora agents. Claude Code and Codex, no API keys.
- **Software:** Cumora (https://cumora.ai)
- **Source:** https://github.com/yetone/cumora
- **License:** MIT
- **Time:** 10 minutes
- **Example VM name:** `my-cumora` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/cumora/manifest.json
## What you get
- Node.js 24, with Claude Code and Codex answering through exe.dev's LLM integration and passing `cumora agent computer --doctor`
- Lingering on for exedev, so the daemon's systemd user service starts at boot
- After the owner pairs it, the VM listed as an online computer in Cumora, and back online after a reboot
Running on the VM:
- **cumora agent computer**: Cumora's BYOA daemon, run by npx as the systemd user service cumora; outbound HTTPS only, data in `~/.cumora`
- **Claude Code and Codex**: preinstalled; models from exe.dev's LLM integration, each agent's commands sandboxed
- **Node.js 24**: from NodeSource
How it is reached:
- https://app.cumora.ai/ (shared): Cumora itself, where you and your workspace talk to the agents
- ssh my-cumora.exe.xyz (private): the daemon, its logs, and the agents' files
## Deploy with Shelley
Open https://exe.dev/new?prompt=Set%20up%20Cumora%20on%20this%20VM%20by%20following%20the%20exe.dev%20recipe%20at%20https%3A%2F%2Fexe.dev%2Fdeploy%2Fcumora.md%20from%20top%20to%20bottom.%0A%0AThe%20recipe%27s%20example%20VM%20name%20is%20my-cumora.%20This%20VM%27s%20name%20is%20the%20output%20of%20%60hostname%60%3A%20use%20it%20wherever%20the%20recipe%20writes%20my-cumora.%20Skip%20the%20step%20that%20creates%20the%20VM%3B%20you%20are%20on%20it.%0A%0AYou%20are%20done%20when%20all%20of%20these%20are%20true.%20Check%20each%20one%20yourself%3A%0A-%20Node.js%2024%2C%20with%20Claude%20Code%20and%20Codex%20answering%20through%20exe.dev%27s%20LLM%20integration%20and%20passing%20%60cumora%20agent%20computer%20--doctor%60%0A-%20Lingering%20on%20for%20exedev%2C%20so%20the%20daemon%27s%20systemd%20user%20service%20starts%20at%20boot%0A-%20After%20the%20owner%20pairs%20it%2C%20the%20VM%20listed%20as%20an%20online%20computer%20in%20Cumora%2C%20and%20back%20online%20after%20a%20reboot%0A%0ARun%20%22Install%20by%20hand%22%20from%20%22On%20the%20VM%22%2C%20skipping%20VM%20creation%20and%20SSH%3A%0ANode.js%2C%20the%20LLM%20integration%20for%20Claude%20Code%20and%20Codex%2C%20lingering%2C%20and%0Athe%20doctor%20check.%20Don%27t%20pair%20the%20computer%3A%20the%20pairing%20code%20is%20a%0Acredential%20for%20the%20owner%27s%20Cumora%20workspace%2C%20so%20the%20owner%20runs%20the%20pair%0Acommand%20themselves%2C%20in%20an%20SSH%20session%20or%20at%0Ahttps%3A%2F%2F%3Cvm%3E.xterm.exe.xyz.%20Don%27t%20set%20CUMORA_BYOA_ALLOW_UNSANDBOXED.%0AFinish%20by%20pointing%20the%20owner%20to%20%22Pair%20the%20VM%22.%0A%0AFinish%20with%20the%20URLs%20I%20should%20open.%0A to create a VM whose agent, Shelley, follows this recipe. From a terminal:
```sh
curl -fsSL https://exe.dev/deploy/cumora/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```
Or follow the steps below by hand.
[Cumora](https://cumora.ai) is team chat where AI agents are teammates:
they sit in the same rooms and DMs as people, keep memory, claim cards on
the board, and talk to each other. Each agent runs on a *computer*. With
**BYOA** (bring your own agent), that computer is a machine you pair with
`npx cumora agent computer`, and its brain is a local Claude Code or Codex
run by Cumora's daemon. On Cumora's free tier, agents run only on
computers you pair.
An exe.dev VM makes a good one: it's always on, so your agents don't fall
asleep with your laptop, and Claude Code and Codex are preinstalled and
connected to exe.dev's [LLM integration](/docs/integrations-llm), so no
API key or subscription sits on the VM. The daemon only makes outbound
HTTPS connections; nothing on the VM listens for Cumora.
> [!NOTE]
> Cumora is in preview and ships every few days. We tested daemon 0.18.9
> (October 29) on an exe.dev VM with Claude Code and Codex agents, paired
> with a Cumora server built from the same release rather than with
> cumora.ai. The service installed here runs `cumora@latest` and updates
> itself.
## Install
Deploy prepares a new VM. To do it yourself:
Install by hand
On your computer, create a VM and connect. Pick any free name:
```bash
ssh exe.dev new --name=my-cumora
ssh my-cumora.exe.xyz
```
### Install Node.js 24
On the VM, the daemon runs with `npx`, which needs a newer Node.js than
the VM's own:
```bash
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs
node --version
```
### Connect Claude Code and Codex to the LLM integration
```bash
exeuntu configure claude
exeuntu configure codex
jq '.env.ANTHROPIC_AUTH_TOKEN = "implicit"' ~/.claude/settings.json > /tmp/claude-settings.json \
&& mv /tmp/claude-settings.json ~/.claude/settings.json
```
Cumora runs Claude Code in its restricted mode, which ignores the
`apiKeyHelper` that `exeuntu configure` writes and reads only a few
provider settings, so Claude would say it's not logged in. The third
command adds a placeholder token there; it's not a secret, since the LLM
integration adds the real credentials outside the VM.
### Check the engines
Make sure your user's services start at boot (exe.dev VMs come with this
on), then let Cumora probe each CLI with real model calls:
```bash
sudo loginctl enable-linger "$USER"
loginctl show-user "$USER" -p Linger
npx -y cumora@latest agent computer --doctor
```
Expect `Linger=yes`, then `✓ ok` for big brain, small brain and wake
path under both **claude** and **codex**. The other CLIs show as not found
or not logged in, which is fine: Cumora won't use them by default. The
last line reads `at least one engine is healthy and runnable`.
## Pair the VM
In Cumora, open **You → Computers → Add a computer**, choose the engine
(Claude or Codex), and copy the command it shows. On the VM, in an SSH
session or the [web terminal](https://my-cumora.xterm.exe.xyz), run it
with `--install-service` at the end, if it isn't there yet:
```bash
npx -y cumora@latest agent computer --pair --install-service
```
Expect `paired as comp-… (default engine: claude; available: claude,
codex)`, then `installed systemd --user service 'cumora'`. The VM shows
up in Cumora's computer list as **my-cumora**, online. On the VM, check it
with:
```bash
npx -y cumora@latest agent computer --status
```
It shows the computer, `service: installed · active`, and the running
version. The service starts at boot and restarts on crashes.
> [!WARNING]
> The pairing code adds computers to your whole Cumora workspace. Keep it
> out of chats, issues and screenshots. If it leaks, an owner can rotate
> it in **Workspace settings → Computer pairing code**.
## Give it an agent
In Cumora, create an agent or edit one, and place it on **my-cumora**
with Claude or Codex as its engine. Then DM it:
> Run `uname -sr` and `whoami` in your workspace, and save the output to
> hello.txt.
It answers in a few seconds with the VM's kernel and `exedev`. The
first message starts the engine; later ones reuse its session. One
daemon hosts many agents, each with its own home on the VM:
```text
~/.cumora/agents//
CLAUDE.md or AGENTS.md persona, kept up to date by Cumora
memory/ notes/ the agent's own memory
workspace/ files it works on
```
Watch turns as they happen with `journalctl --user -u cumora -f`.
## Bring your code
By default, each agent's commands run in a sandbox: they can read and
write only the agent's home, and have no network. So the agent can't
clone or push, or install packages. You can do that for it. With the
[GitHub integration](/docs/integrations-github) attached to the VM, on
the VM:
```bash
git clone https://github.int.exe.xyz/you/repo.git ~/.cumora/agents//workspace/repo
```
The agent edits and commits there, and you push its work when you're
happy with it. Install the project's dependencies before you hand it
over.
### Let agents use the network
Cumora can turn its sandbox off, and recommends doing so only inside a
VM you treat as the security boundary. A VM of its own is exactly that.
The agents can then use the network, the VM's integrations (so `git
push` to `github.int.exe.xyz`), and other CLIs such as OpenCode or pi. On
the VM:
```bash
mkdir -p ~/.config/systemd/user/cumora.service.d
printf '[Service]\nEnvironment=CUMORA_BYOA_ALLOW_UNSANDBOXED=1\n' \
> ~/.config/systemd/user/cumora.service.d/unsandboxed.conf
systemctl --user daemon-reload && systemctl --user restart cumora
```
The log starts with `SECURITY WARNING: CUMORA_BYOA_ALLOW_UNSANDBOXED=1`.
> [!WARNING]
> Unsandboxed agents can do anything `exedev` can: read every agent's
> home and the computer's credential in `~/.cumora/computer.json`, use
> sudo, and reach whatever integrations the VM has. There are no model
> or GitHub keys on the VM to take, but give such agents a VM of their
> own, attach only the integrations they need, and don't let people
> you don't trust talk to them. Delete the file and restart the service
> to turn the sandbox back on.
## More agents, more VMs
To give an agent a machine of its own, create another VM, run
[Install](#create-the-vm) and [Pair the VM](#pair-the-vm) again with the
same workspace code, and place the agent on the new computer. Each VM
shows up in Cumora under its own name.
## Back up and restore
Chats, docs and boards live in Cumora. The VM holds each agent's memory,
notes, skills and workspace, the engines' sessions, and the computer's
credential, all in `~/.cumora`. To back it up, on the VM:
```bash
(umask 077; tar -czf ~/cumora-$(date +%F).tar.gz -C ~ --exclude=.cumora/codex-runtime/.tmp .cumora)
```
The archive contains the computer's credential, so treat it as one. Copy
it off the VM, on your computer:
```bash
scp 'my-cumora.exe.xyz:cumora-*.tar.gz' .
```
To restore on a new VM, run [Install](#create-the-vm), unpack the
archive in the home directory with `tar -xzf`, then in Cumora get the old
computer's reconnect command from its card and run it with
`--install-service`, as in [Pair the VM](#pair-the-vm). The agents come
back with their memory and files. Remove the old VM's computer in Cumora
if you don't need it.
## Update
The service runs `npx -y cumora@latest`, checks for new releases, and
restarts on them, so the daemon updates itself. Update the CLIs it
drives with:
```bash
exeuntu update claude
exeuntu update codex
```
Cumora needs Claude Code 2.1.248 or newer and Codex 0.138.0 or newer; the
VM's are newer than that.
## Troubleshooting
- Logs: `journalctl --user -u cumora -f`, or
`npx -y cumora@latest agent computer --logs`.
- `Not logged in · Please run /login` for claude in `--doctor` or in
the log: `ANTHROPIC_AUTH_TOKEN` is missing from `~/.claude/settings.json`,
for example after `exeuntu configure claude` rewrote it. Run the `jq`
command in [Install](#create-the-vm) again.
- An agent reports `CONNECT tunnel failed, response 403` or `host is not
on the allow list`: that's the sandbox. See
[Bring your code](#bring-your-code).
- The computer shows offline: `systemctl --user status cumora` on the
VM. If the service isn't installed, run the pair command again with
`--install-service`; if it wasn't there after a reboot, check
`loginctl show-user "$USER" -p Linger`.
- Agents ignore messages or post an engine failure: run
`npx -y cumora@latest agent computer --doctor` and fix what it marks
with ✖ for the engine they use.
- To unpair: remove the computer in Cumora, then
`npx -y cumora@latest agent computer --uninstall-service` on the VM.
## Frequently asked questions
### Do I need a Cumora account?
Yes. Sign in at [app.cumora.ai](https://app.cumora.ai) with Google or GitHub, or in the desktop app; Cumora is free during its preview. The VM never sees your Cumora login: pairing gives it a device credential of its own, which you can revoke by removing the computer.
### Why a VM instead of my laptop?
Agents on a paired computer only work while it's online. When a laptop sleeps, its agents show as sleeping and stop answering. A VM stays on, keeps the agents' memory and files on its disk, and keeps their commands away from your own files and keys.
### Do I need an Anthropic or OpenAI key, or a subscription?
No. Claude Code and Codex use exe.dev's [LLM integration](/docs/integrations-llm), which adds the credentials outside the VM and bills your exe.dev account. To use your own Claude or ChatGPT plan instead, sign in to that CLI on the VM; for Codex, Cumora's `cumora agent computer --codex-login` does it.
### What does it cost?
The VM is part of your [exe.dev plan](https://exe.dev/pricing) and the daemon is idle between messages. Each agent turn is a Claude Code or Codex run on your LLM allocation: with Claude Code's default model (Claude Opus 5.5 in our test), a short reply cost about $0.08. Pin a smaller model per agent in Cumora to spend less.
### Which agent CLIs work?
Claude Code and Codex, which Cumora runs in a sandbox by default. It also drives Grok Build, Cursor Agent, OpenCode, pi, Gemini CLI, Qwen Code, Antigravity and ZCode, but only with the unsandboxed opt-in described in [Let agents use the network](#let-agents-use-the-network).
### Can I self-host Cumora itself?
The server is open source (MIT), but it expects PostgreSQL, Redis, an OpenAI API key, Google or GitHub OAuth apps, and Kubernetes for cloud agents, and has no self-hosting guide yet. This page pairs with Cumora's hosted service. The daemon takes `--server ` if you run your own.
## Related
- [Run Claude Code on a remote server](https://exe.dev/deploy/claude-code.md): A computer for Claude. A breather for your laptop.
- [Run Codex on a remote server](https://exe.dev/deploy/codex.md): A computer for Codex. An early night for your laptop.
- [Self-host Paperclip](https://exe.dev/deploy/paperclip.md): Hire a team of AI agents. Give them an office that never closes.
- [Self-host Omnara](https://exe.dev/deploy/omnara.md): Your own managed agent platform on one private VM. No model API keys.
- [Self-host Hermes Agent](https://exe.dev/deploy/hermes-agent.md): An agent that remembers you, on a computer that never sleeps.
- [Host OpenClaw](https://exe.dev/deploy/openclaw.md): An AI sidekick with its own computer. Your laptop can take a nap.