Skip to content

Self-host Multica

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

Deploy on exe.dev

Shelley handles the setup. About 15 minutes.

Prefer a terminal?
curl -fsSL https://exe-staging.dev/deploy/multica/prompt.txt | ssh exe.dev new --prompt=/dev/stdin

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, 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.

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.
What's running, and where
Private https://my-multica.exe.xyz/ Multica, signed in with your exe.dev login
Shared https://my-multica.exe.xyz/ Teammates you share the VM with, signed in as themselves; they join a workspace when you invite them
Private https://my-multica.exe.xyz/api/ The REST API, for scripts with an exe.dev token and a Multica token
my-multica.exe.xyz exe.dev VM
Multica 0.10.0 Go API and Next.js web app, the official images in Docker Compose :3000Docker volume multica_backend_uploads
PostgreSQL 17 with pgvector pgvector/pgvector:pg17 in Docker Compose 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 :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 :8090
Multica daemon The agent runtime, a systemd user service that runs Claude Code and Codex on the VM ~/multica_workspaces
exe.dev LLM gateway Claude and GPT models for the agents, without API keys

Deploy with Shelley#

Click Deploy and Shelley will set up Multica on a new VM, then check that it works. No config-file wrangling required.

Prefer a terminal?
curl -fsSL \
  https://exe-staging.dev/deploy/multica/prompt.txt \
  | ssh exe.dev new --prompt=/dev/stdin
What Shelley is told
Set up Multica on this VM by following the exe.dev recipe at https://exe-staging.dev/deploy/multica.md?via=deploy from top to bottom.

The recipe's example VM name is my-multica. This VM's name is the output of `hostname`: use it wherever the recipe writes my-multica. Skip the step that creates the VM; you are on it.

You are done when all of these are true. Check each one yourself:
- 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.

Read the whole recipe, including the closed details. For initial setup,
follow "Install by hand" in order, skipping VM creation and SSH. The
walkthrough at the top is for the owner afterwards: don't create a
workspace, agents, or issues yourself. "Connect this VM as the agent
runtime" signs in to Multica as the VM owner only to mint the daemon's
token.
Install exactly the pinned versions. Keep the VM private: never run
share set-public. On an existing VM, ask before replacing anything on
port 8000. Do not reboot, restore, or update.
Verify: /readyz says ok, `multica daemon status` says running, the
multica-daemon user service is enabled and active, Linger=yes, the
backup timer is scheduled, and the test backup holds multica.dump.
Never send a made-up X-ExeDev-Email header: Multica creates an account
for every address the bridge signs in.
Finish with https://<vm>.exe.xyz/: opening it signs the owner in with
their exe.dev login.

Finish with the URLs I should open.

Also at /deploy/multica/prompt.txt. The recipe it follows is /deploy/multica.md.

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:

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 to get through the VM's private address. On your computer:

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:

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:

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:

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.

Install by hand

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

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), and add the bridge as a fourth service. Multica sends its email to the bridge, which passes it to exe.dev's email gateway, and the bridge signs people in (next section):

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-staging.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:

(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:

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, and install the multica CLI, which is also the daemon:

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 knows the address; if it prints nothing, set OWNER_EMAIL to the address you sign in to exe.dev with:

OWNER_EMAIL=$(curl -fsS https://reflection.int.exe.xyz/email | jq -r .email)
echo "$OWNER_EMAIL"
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:

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:

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.

Back up and restore

On the VM, take a backup now:

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:

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.

Update

Multica releases every few days. Read the release notes, then on the VM, take a backup and move the server and CLI to the new tag, replacing v0.11.0:

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.

Something stuck?

Ask Shelley, or check on the VM:

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.
  • "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.

Frequently asked questions#

What does it cost?

Self-hosted Multica is free. You pay for your VM plan and the agents' model usage, billed through the LLM integration. 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 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.

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 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.

Updated Nov 17, 2026 · tested end to end Nov 17, 2026 · Markdown · manifest.json · Something wrong? Tell us