---
title: "Self-host Multica"
description: "Run Multica, the issue board where coding agents take the tickets, on an exe.dev VM: Claude Code and Codex on the same VM, no API keys to paste."
url: https://exe.dev/deploy/multica
category: "AI agents"
updated: 2026-11-17
---

# Self-host Multica

> **For agents:** with your user's OK, this sets up Multica on a new exe.dev VM in their account: `curl -fsSL https://exe.dev/deploy/multica/prompt.txt | ssh exe.dev new --prompt=/dev/stdin` (or open https://exe.dev/deploy/multica/new). Already on the VM? Skip this.

An issue board where Claude Code and Codex take the tickets.

- **Software:** Multica (https://multica.ai)
- **Source:** https://github.com/multica-ai/multica
- **License:** Multica License (source-available)
- **Time:** 15 minutes
- **Example VM name:** `my-multica` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/multica/manifest.json
- **File:** https://exe.dev/deploy/multica/exe-bridge.py

## What you get

- Multica 0.10.0 at your VM's private URL, signing you and your teammates in with your exe.dev logins, back after a reboot.
- The VM connected as Multica's agent runtime, with Claude Code and Codex on exe.dev's LLM gateway and no API keys on the VM.
- The `multica` CLI signed in on the VM, so you, Shelley, and scripts can create, assign, and close issues.
- Generated secrets in one private file, and a nightly backup of the database, uploads, and secrets, with a tested restore.

Running on the VM:

- **Multica 0.10.0**: Go API and Next.js web app, the official images in Docker Compose, port 3000, data in `Docker volume multica_backend_uploads`
- **PostgreSQL 17 with pgvector**: pgvector/pgvector:pg17 in Docker Compose, data in `Docker volume multica_pgdata`
- **nginx**: Serves the web app on port 8000, sends WebSockets straight to the API, and signed-out visitors to the bridge, port 8000
- **exe.dev bridge**: A small Python service that signs people in with their exe.dev login and sends Multica's email through exe.dev's email gateway, port 8090
- **Multica daemon**: The agent runtime, a systemd user service that runs Claude Code and Codex on the VM, data in `~/multica_workspaces`
- **exe.dev LLM gateway**: Claude and GPT models for the agents, without API keys

How it is reached:

- https://my-multica.exe.xyz/ (private): Multica, signed in with your exe.dev login
- https://my-multica.exe.xyz/ (shared): Teammates you share the VM with, signed in as themselves; they join a workspace when you invite them
- https://my-multica.exe.xyz/api/ (private): The REST API, for scripts with an exe.dev token and a Multica token

## Deploy with Shelley

Open https://exe.dev/deploy/multica/new to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe.dev/deploy/multica/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```

Or follow the steps below by hand.

Multica is an issue board where some of the assignees are coding agents.
You file an issue and assign it to an agent, and the agent picks it up,
does the work, comments on the issue, and moves it along the board, the
way a teammate would. Agents are the coding CLIs you already use: Claude
Code, Codex, OpenCode, Pi, and about twenty more. They run on a
*runtime*, any computer running Multica's daemon.

On exe.dev, the board and the runtime share one VM. Multica runs in
Docker, private behind your exe.dev login; its daemon runs beside it as a
systemd service, with Claude Code and Codex preinstalled and connected to
exe.dev's [LLM gateway](/docs/integrations-llm), so there are no API keys
to paste. You and your teammates sign in with your exe.dev logins, and
the VM stays on while agents work.

## Sign in

Open `https://my-multica.exe.xyz/`. exe.dev's login is Multica's login,
so you're signed in a second later as the email address you use for
exe.dev.

The first time, Multica sets you up. Click **Continue on web** (you don't need the
desktop app), answer or skip **About you**, then name your workspace;
its URL name and issue prefix (`ACME` makes `ACME-1`) follow the name.
On **Connect a computer**, click **Show steps** under **Connect from the
terminal**. Ignore the install commands: this VM is already connected,
with **Claude (my-multica)**, **Codex (my-multica)** and more listed.
Pick **Claude** and click **Start with Mika**. Mika is your first agent,
and opens a chat to help you get going.

## Give an agent an issue

Click the pencil at the top of the left rail to create an issue. It opens
in **Create with agent** mode; click **Switch to Manual** to give the issue
a title and description yourself, for example:

> **Say hello.** Write a file HELLO.md in your workspace with a one-line
> greeting, then comment on this issue with the greeting.

Set the assignee to **Mika** (it may already be) and click **Create Issue**. Within a minute the issue
moves to **In Progress**, Mika comments with the greeting, and the issue
lands in **In Review** for you to check. Click the run on the issue to
see every step the agent took.

To add a Codex agent, open **Team**, click **+** (New agent) at the top
right, choose the machine **my-multica**, then **Codex**, and give it a
name. Each agent has its own instructions, model, and skills.

> [!WARNING]
> **Keep this VM private.** Multica starts Claude Code and Codex with
> their permission prompts and sandboxes off, and they can use `sudo`.
> Anyone who can assign an issue can run commands on the VM. Don't make
> the VM public or keep unrelated secrets on it.

## Issues from the command line

The `multica` CLI on the VM is signed in as you. On the VM, point it at
your workspace once (its URL name, `acme` in `https://my-multica.exe.xyz/acme/issues`),
then work with issues:

```bash
multica workspace switch acme
multica issue create --title "Tidy the README" --assignee Mika
multica issue list
multica issue comment add ACME-2 --content "Looks good, thanks"
multica issue status ACME-2 done
```

That makes Multica easy to drive from other agents: ask Shelley on the VM
to "file a Multica issue for the flaky test and assign it to Codex", and
it can use the same commands. Multica's own agents use the CLI to comment
and change status, too.

Scripts elsewhere can use the REST API. They need two tokens: a Multica
token from **Settings → API Tokens**, and an
[exe.dev token](/docs/https-tokens-for-vms) to get through the VM's
private address. On your computer:

```bash
ssh exe.dev ssh-key generate-api-key --vm=my-multica --label=multica-api --exp=90d
```

Then send both, with your workspace's URL name:

```bash
curl https://my-multica.exe.xyz/api/issues \
  -H "X-Exedev-Authorization: Bearer exe1.paste-yours-here" \
  -H "Authorization: Bearer mul_paste-yours-here" \
  -H "X-Workspace-Slug: acme" \
  -H "Content-Type: application/json" \
  -d '{"title": "Created from a script"}'
```

`POST /api/issues/<id>/comments` with `{"content": "…"}` comments, and
`PUT /api/issues/<id>` with `{"status": "done"}` closes it.

## Bring your team

On your computer, share the VM:

```bash
ssh exe.dev share add my-multica teammate@example.com
```

They open the link from exe.dev's email, sign in to exe.dev, and land in
Multica signed in as themselves, with an account of their own. Then
invite them to your workspace from **Settings → Members**: the
invitation waits for them in Multica (and exe.dev emails it, too), and
they join as members. You stay the workspace owner. Until you invite
them, they can only make workspaces of their own.

**Log out** in Multica's account menu signs you out. To come back, open
`https://my-multica.exe.xyz/` and click **Sign in again**; the same page
can sign you out of exe.dev too, which is how you switch exe.dev
accounts. If someone else signs in to exe.dev in the same browser, the
next page they open signs them in to Multica as themselves. If you log out and sign back
in within a minute, the bridge waits out Multica's one-code-a-minute limit. (Right after logging out, Multica may show its own email
sign-in form. That works too, but you don't need it.)

## Keep your work

Issues, comments, agents, and settings live in PostgreSQL; attachments in
the uploads volume. Each night at about 3:30 UTC, a timer dumps the
database and copies the uploads and `~/multica/.env` to
`~/backups/multica`, keeping two weeks. Copy them **off the VM** too. On
your computer:

```bash
rsync -av my-multica.exe.xyz:backups/multica/ ./multica-backups/
```

Keep those copies private: `.env` holds the secret that signs every
session.

## Setup and upkeep

No need to read on unless you're curious, or doing it yourself.

<details id="create-the-vm" data-manual-setup class="dp-details">
<summary>Install by hand</summary>

On your computer (pick another name if `my-multica` is taken):

```bash
ssh exe.dev new --name=my-multica
ssh my-multica.exe.xyz
```

All remaining commands run **on the VM**, as `exedev`.

### Start Multica

Multica's self-host stack is its Compose file: PostgreSQL 17 with
pgvector, the API, and the web app, all on `127.0.0.1`. Fetch it at the
pinned release, with the exe.dev bridge
([`exe-bridge.py`](https://exe.dev/deploy/multica/exe-bridge.py)), and
add the bridge as a fourth service. Multica sends its email to the
bridge, which passes it to exe.dev's [email gateway](/docs/send-email),
and the bridge signs people in (next section):

```bash
sudo systemctl enable --now docker.service
mkdir -p ~/multica && cd ~/multica
curl -fsSL -o compose.yaml \
  https://raw.githubusercontent.com/multica-ai/multica/v0.10.0/docker-compose.selfhost.yml
curl -fsSLO https://exe.dev/deploy/multica/exe-bridge.py
cat > compose.override.yaml <<'EOF'
services:
  bridge:
    image: python:3.13-alpine
    command: ["python3", "-u", "/exe-bridge.py"]
    volumes:
      - ./exe-bridge.py:/exe-bridge.py:ro
    ports:
      - "127.0.0.1:8090:8090"
    restart: unless-stopped
EOF
```

The settings and generated secrets go in one file, readable only by you.
The URLs tell Multica its public address, so cookies, links, and
WebSockets work behind the [HTTPS proxy](/docs/proxy):

```bash
(umask 077; cat > .env <<EOF
MULTICA_IMAGE_TAG=v0.10.0
POSTGRES_PASSWORD=$(openssl rand -hex 24)
JWT_SECRET=$(openssl rand -hex 32)
FRONTEND_ORIGIN=https://$(hostname).exe.xyz
CORS_ALLOWED_ORIGINS=https://$(hostname).exe.xyz
MULTICA_APP_URL=https://$(hostname).exe.xyz
MULTICA_PUBLIC_URL=https://$(hostname).exe.xyz
GOOGLE_REDIRECT_URI=https://$(hostname).exe.xyz/auth/callback
SMTP_HOST=bridge
SMTP_PORT=2525
SMTP_FROM_EMAIL=multica@$(hostname).exe.xyz
EOF
)
docker compose pull -q
docker compose up -d
curl -fsS --retry 30 --retry-all-errors --retry-delay 2 http://127.0.0.1:8080/readyz
```

Expect `{"status":"ok","checks":{"db":"ok","migrations":"ok"}}`, after a
few `curl: (56)` or `(52)` errors while the API sets up its database.
The images are about 1.3 GB; the pull takes a minute or two.

### Sign people in with exe.dev

exe.dev's proxy sends `https://my-multica.exe.xyz/` to port 8000 and
tells the VM who is visiting in an `X-ExeDev-Email` header. Multica
can't read that header: it signs people in only with a 6-digit code it
emails them. So nginx sends signed-out visitors to the bridge at
`/exe-login`, which asks Multica for a code for the visitor's address
(`POST /auth/send-code`), keeps that one email instead of sending it,
hands the code back (`POST /auth/verify-code`), and passes Multica's
session cookies to the browser. Everything else goes to the web app,
which forwards `/api` and `/auth` to the API, and WebSockets go straight
to the API. nginx listens only on 127.0.0.1, where the proxy connects,
so nothing but the proxy can reach it from outside the VM:

```bash
sudo tee /etc/nginx/sites-available/multica >/dev/null <<'EOF'
# Plain /login, not the CLI or desktop app handing over a session.
map $arg_cli_callback$arg_platform $multica_plain_login {
    "" 1;
    default 0;
}

# A browser navigation whose Multica session belongs to another exe.dev user.
map "$http_sec_fetch_mode|$cookie_exe_who|$http_x_exedev_email" $exe_user_changed {
    "~*^navigate\|([^|]+)\|\1$" 0;
    "~*^navigate\|[^|]+\|." 1;
    default 0;
}

server {
    listen 127.0.0.1:8000;
    client_max_body_size 100m;
    absolute_redirect off;

    location = / {
        if ($cookie_multica_auth = "") {
            return 302 /exe-login;
        }
        if ($exe_user_changed) {
            return 302 /exe-login;
        }
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto https;
    }

    location = /login {
        set $exe_login "";
        if ($cookie_multica_auth = "") {
            set $exe_login $multica_plain_login;
        }
        if ($exe_user_changed) {
            set $exe_login $multica_plain_login;
        }
        if ($exe_login = 1) {
            return 302 /exe-login$is_args$args;
        }
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto https;
    }

    # Remember a logout, so /exe-login doesn't sign the person straight back in.
    location = /auth/logout {
        add_header Set-Cookie "exe_signed_out=1; Path=/; Secure; HttpOnly; SameSite=Lax" always;
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto https;
    }

    location /exe-login {
        proxy_pass http://127.0.0.1:8090;
        proxy_set_header Host $host;
        proxy_read_timeout 120s;
    }

    location /ws {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_read_timeout 86400;
    }

    location / {
        if ($exe_user_changed) {
            return 302 /exe-login;
        }
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
    }
}
EOF
sudo ln -sf /etc/nginx/sites-available/multica /etc/nginx/sites-enabled/multica
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl enable nginx && sudo systemctl restart nginx
curl -s -o /dev/null -w '%{http_code} %header{location}\n' http://127.0.0.1:8000/
curl -fsS --retry 10 --retry-all-errors --retry-delay 2 http://127.0.0.1:8000/api/config | jq -r .server_version
```

Expect `302 /exe-login` and `v0.10.0`.

### Connect this VM as the agent runtime

The daemon runs agents for one Multica account: yours. Connect Claude
Code and Codex to the [LLM gateway](/docs/integrations-llm), and install
the `multica` CLI, which is also the daemon:

```bash
exeuntu configure claude
exeuntu configure codex
mkdir -p ~/.local/bin
curl -fsSL "https://github.com/multica-ai/multica/releases/download/v0.10.0/multica-cli-0.10.0-linux-$(dpkg --print-architecture).tar.gz" |
  tar -xz -C ~/.local/bin multica
export PATH="$HOME/.local/bin:$PATH"
multica version
```

Expect `multica 0.10.0`.

The daemon needs a token. The VM signs in through the bridge as your
exe.dev email address, the way the proxy will, and makes one. The
[Reflection integration](/docs/integrations-reflection) knows the
address; if it prints nothing, set `OWNER_EMAIL` to the address you sign
in to exe.dev with:

```bash
OWNER_EMAIL=$(curl -fsS https://reflection.int.exe.xyz/email | jq -r .email)
echo "$OWNER_EMAIL"
```

```bash
JWT=$(curl -fsS -o /dev/null -D - -H "X-ExeDev-Email: $OWNER_EMAIL" http://127.0.0.1:8000/exe-login/go |
  sed -n 's/^set-cookie: multica_auth=\([^;]*\).*/\1/Ip')
PAT=$(curl -fsS http://127.0.0.1:8080/api/tokens -H "Authorization: Bearer $JWT" \
  -H 'Content-Type: application/json' -d "{\"name\": \"agent runtime on $(hostname)\"}" | jq -r .token)
multica config set server_url http://127.0.0.1:8080
multica config set app_url "https://$(hostname).exe.xyz"
(umask 077; jq --arg t "$PAT" '.token = $t' ~/.multica/config.json > ~/.multica/config.new &&
  mv ~/.multica/config.new ~/.multica/config.json)
unset JWT PAT
multica auth status
```

Expect your email after `User:`. The token goes straight into
`~/.multica/config.json`, readable only by you, because `multica login`
would sit waiting for you to create a workspace in the browser. It shows
under **Settings → API Tokens** as "agent runtime on my-multica".

Run the daemon as a systemd user service, started at boot:

```bash
sudo loginctl enable-linger "$USER"
multica daemon autostart enable
systemctl --user start multica-daemon
sleep 5
loginctl show-user "$USER" -p Linger
systemctl --user is-enabled multica-daemon
systemctl --user is-active multica-daemon
multica daemon status
```

Expect `Linger=yes`, `enabled`, `active`, and `Daemon: running` with
claude, codex, opencode and pi under `Agents:` (in any order).

### Set up nightly backups

The backup dumps the database while Multica runs and copies the uploads
and `.env`:

```bash
cat > ~/multica/backup.sh <<'EOF'
#!/bin/sh
set -eu
cd "$HOME/multica"
umask 077
dest="$HOME/backups/multica/$(date +%Y%m%d-%H%M)"
mkdir -p "$dest"
docker compose exec -T postgres pg_dump -U multica -Fc multica > "$dest/multica.dump"
docker compose exec -T backend tar -C /app/data -czf - uploads > "$dest/uploads.tar.gz"
cp .env "$dest/env"
find "$HOME/backups/multica" -mindepth 1 -maxdepth 1 -type d -mtime +13 -exec rm -rf {} +
EOF
chmod 700 ~/multica/backup.sh
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/multica-backup.service <<'EOF'
[Unit]
Description=Multica backup

[Service]
Type=oneshot
ExecStart=%h/multica/backup.sh
EOF
cat > ~/.config/systemd/user/multica-backup.timer <<'EOF'
[Unit]
Description=Nightly Multica backup

[Timer]
OnCalendar=*-*-* 03:30:00
RandomizedDelaySec=30m
Persistent=true

[Install]
WantedBy=timers.target
EOF
systemctl --user daemon-reload
systemctl --user enable --now multica-backup.timer
systemctl --user start multica-backup.service
ls -l "$(ls -d ~/backups/multica/* | tail -1)"
systemctl --user list-timers --no-pager multica-backup.timer
```

Expect `env`, `multica.dump`, and `uploads.tar.gz`, and a scheduled next
run. Then open `https://my-multica.exe.xyz/login` and
[sign in](#sign-in).

</details>

<details id="back-up-and-restore" class="dp-details">
<summary>Back up and restore</summary>

On the VM, take a backup now:

```bash
systemctl --user start multica-backup.service
ls ~/backups/multica | tail -3
```

To restore one, set `B` to its folder. This replaces the database and
uploads; the daemon reconnects by itself:

```bash
B=~/backups/multica/20261117-0330
cd ~/multica
docker compose stop backend frontend
docker compose exec -T postgres dropdb -U multica multica
docker compose exec -T postgres createdb -U multica multica
docker compose exec -T postgres pg_restore -U multica -d multica < "$B/multica.dump"
docker compose run --rm --no-deps -T --entrypoint sh backend \
  -c 'rm -rf /app/data/uploads/* && tar -C /app/data -xzf -' < "$B/uploads.tar.gz"
docker compose start backend frontend
```

Sign in and check your issues are there.

Moving to a new VM? Follow "Install by hand" there up to "Sign people
in with exe.dev", but before `docker compose up -d`, copy the old `env`
over `~/multica/.env` and change the six addresses to the new name. Then
restore as above, and connect the runtime: make a token under
**Settings → API Tokens**, and run the `multica config set`, `multica
login --token` (it asks for the token), and daemon commands.

</details>

<details id="update" class="dp-details">
<summary>Update</summary>

Multica releases every few days. Read the
[release notes](https://github.com/multica-ai/multica/releases), then on
the VM, take a backup and move the server and CLI to the new tag,
replacing `v0.11.0`:

```bash
V=v0.11.0
systemctl --user start multica-backup.service
cd ~/multica
curl -fsSL -o compose.yaml \
  "https://raw.githubusercontent.com/multica-ai/multica/$V/docker-compose.selfhost.yml"
sed -i "s/^MULTICA_IMAGE_TAG=.*/MULTICA_IMAGE_TAG=$V/" .env
docker compose pull -q && docker compose up -d
curl -fsSL "https://github.com/multica-ai/multica/releases/download/$V/multica-cli-${V#v}-linux-$(dpkg --print-architecture).tar.gz" |
  tar -xz -C ~/.local/bin multica
curl -fsS --retry 30 --retry-all-errors --retry-delay 2 http://127.0.0.1:8080/readyz
multica version
```

The API updates the database as it starts. The daemon notices the new
CLI and restarts into it once no agent is running.

</details>

<details id="troubleshooting" class="dp-details">
<summary>Something stuck?</summary>

Ask Shelley, or check on the VM:

```bash
cd ~/multica
docker compose ps
docker compose logs --tail 40 backend
docker compose logs --tail 20 bridge
multica daemon status
multica daemon logs -n 40
```

- **"Couldn't sign you in to Multica"?** The page says what Multica
  answered; `docker compose logs bridge` has the details. Multica allows
  one sign-in per address a minute, so the bridge waits up to a minute
  if you sign in twice in a row.
- **An invitation or other email doesn't arrive?** `docker compose logs
  bridge` shows what exe.dev's gateway said. `403 ... can only send
  email to` means the address isn't yours, your team's, or someone who
  has opened the shared VM. Check spam, too.
- **Agents never start, or the onboarding finds no computer?** Run
  `systemctl --user restart multica-daemon`, then `multica daemon
  status`; it should list your workspace. `multica runtime list` shows
  each runtime's status.
- **A run fails?** Open it on the issue for the agent's log. Run
  `exeuntu configure claude` (or `codex`) again, and check your
  [LLM integration](/docs/integrations-llm).
- **"401" in the daemon log after you revoked its token?** Make a new
  one under **Settings → API Tokens**, run `multica login --token` and
  paste it, then restart the daemon.
- **Live updates stop and comments appear only after a reload?** The
  WebSocket isn't getting through. Check the `/ws` block in
  `/etc/nginx/sites-available/multica` and that `.env` has the VM's
  `https://` address in `CORS_ALLOWED_ORIGINS`.
- **The disk fills up?** Agents' working folders are in
  `~/multica_workspaces`; `du -sh ~/multica_workspaces` and
  `docker system df` show where the space went.

</details>

## Frequently asked questions

### What does it cost?

Self-hosted Multica is free. You pay for your [VM plan](https://exe.dev/pricing) and the agents' model usage, billed through the [LLM integration](/docs/integrations-llm). Multica shows each agent's token use on its runs.

### Is Multica open source?

It's source-available. The Multica License is Apache-2.0 plus extra conditions: without a commercial license you may not run Multica as a hosted service for people outside your organization (even for free) or embed it in a product you sell, and you may not remove or change the Multica logo, name, or copyright notices in its interface. Running it for your own team, as here, is allowed. We found no features held back for a paid edition in the self-hosted build.

### Can people sign in with their exe.dev login?

Yes, that's how this setup works. Multica itself only signs people in with a 6-digit code it emails them. exe.dev's [proxy](/docs/proxy) tells the VM who is visiting, so a small bridge on the VM asks Multica for a code for that address, catches the code on its way out, and hands it straight back. Everyone you share the VM with gets a Multica account on their first visit. Multica's own email sign-in still works, too: codes go out through exe.dev's [email gateway](/docs/send-email).

### Can someone fake the exe.dev login?

Not from outside. The proxy removes any `X-ExeDev-*` headers a browser sends and adds its own for the signed-in user, and nginx and the bridge listen only on 127.0.0.1. Programs on the VM itself can send the header, and so can Multica's agents, which run there with `sudo`. Anyone who can run commands on the VM can already do anything there.

### Can I use my Claude or ChatGPT subscription?

Yes, through the gateway: point your [LLM integration](/docs/integrations-llm) at your own Anthropic key, OpenAI key, or ChatGPT subscription. The agents keep using `https://llm.int.exe.xyz` and need no change on the VM.

### Can agents run on my laptop or another VM?

Multica's daemon must reach the API, and through exe.dev's private proxy it can't present an exe.dev token. As written, agents run on this VM. We haven't tested daemons elsewhere; making the VM public would let them connect, but then Multica's own email sign-in is the only lock.

### Does Multica send data anywhere?

The server sends one anonymous usage snapshot a day to Multica (version, bucketed counts of workspaces, members and runs; no names, content, or emails). To stop it, add `DO_NOT_TRACK=1` to `~/multica/.env` and run `docker compose up -d` in `~/multica`. Prompts and code go to the model provider through exe.dev's gateway.


## Related

- [Self-hosted issue tracker](https://exe.dev/deploy/issue-tracker.md): Choose an issue tracker to run on your own VM, for your team and your agents.
- [Self-host Paperclip](https://exe.dev/deploy/paperclip.md): Hire a team of AI agents. Give them an office that never closes.
- [Self-host Kanzo, one kanban board for you and your agents](https://exe.dev/deploy/kanzo.md): One kanban board, behind your exe.dev login, that all your agents work from.
- [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.
- [Host OpenClaw](https://exe.dev/deploy/openclaw.md): An AI sidekick with its own computer. Your laptop can take a nap.
