Install an Allin worker

Before deploying

This guide installs a worker connected to your Allin workspace, not a new Allin server. The public image includes the Allin package, Claude Code, Codex and GitHub CLI.

• Prepare a Linux amd64 server with Docker and SSH access. If using Coolify, the server must already be connected to Coolify.
• In Allin → Workers, create a Container worker, select its agents and copy its key. Check queued jobs: they may start as soon as an engine is authenticated.
• ALLIN_URL is your Allin instance address, reachable from the container. ALLIN_WORKER_API_KEY is this worker’s key. Do not run two containers with the same key.
• The server must reach Allin, GHCR, the selected engine’s services and GitHub if used. Remote MCP integrations are called by the Allin server.

Replace USER, WORKER_HOST, WORKER_CONTAINER and PASTE_YOUR_WORKER_KEY_HERE. Do not ask the user to paste secrets into chat: use Coolify’s private variables. The user must complete browser sign-in.

Obtain the user’s approval before creating a paid resource or running a billable job. This guide does not authorize spending.

Docker Compose

Claude Code, Codex and the Allin package are installed in the image. Keep compose.yaml and .env in the same directory.

ssh USER@WORKER_HOST
mkdir -p ~/allin-worker
cd ~/allin-worker

Download Docker Compose

Download Docker profile

curl --fail --location 'https://tryallin.com/downloads/allin-worker.compose.yaml' -o compose.yaml
curl --fail --location 'https://tryallin.com/downloads/allin-worker.seccomp.json' -o allin-worker.seccomp.json

Place allin-worker.seccomp.json next to compose.yaml. The seccomp profile and Compose AppArmor exception allow the Codex sandbox. Use a dedicated host: AppArmor is disabled only for this container, which remains non-privileged, non-root, without capabilities and with no-new-privileges.

ALLIN_WORKER_NAME=allin-worker
ALLIN_URL=https://tryallin.com
ALLIN_WORKER_API_KEY=PASTE_YOUR_WORKER_KEY_HERE

Replace PASTE_YOUR_WORKER_KEY_HERE with the key copied from Allin. Do not share this file.

chmod 600 .env
docker compose pull

Where should I run these commands?

If the worker runs on a remote server, connect to that server over SSH first. Run all Claude, Codex and GitHub commands below in that remote terminal, not on your computer.

ssh USER@WORKER_HOST
cd /path/to/allin-worker

Replace USER, WORKER_HOST and the path with your installation details. With Docker, use the directory containing this worker’s compose.yaml and .env to use its authentication volumes.

Open sign-in links in your computer’s browser. Enter the displayed code if requested, then return to the worker terminal. Credentials stay on the worker server. For a local worker, simply use its local terminal.

Connect GitHub first if your agents use it. Jobs can start as soon as an engine is signed in.

Sign in to Claude Code and/or Codex according to the engines selected for your agents. Restart the worker after adding an account so it recognizes the new engine.

GitHub for cloning repositories

The gh sign-in is used by Git to clone repositories. It does not replace the GitHub MCP connector credentials in Allin.

docker compose run --rm worker gh auth login --hostname github.com --git-protocol https --web
docker compose run --rm worker gh auth setup-git --hostname github.com
docker compose run --rm worker gh auth status --hostname github.com

GitHub CLI is installed in the image. Sign in using the code displayed in the terminal; the github-config volume preserves your sign-in.

If GH_TOKEN or GITHUB_TOKEN is set in the container or machine, gh prioritizes that token. Check that it belongs to the intended account without displaying or sharing it.

To use gh in a job, enable “Run commands” in the agent profile, then create a new job.

Worker Claude account

docker compose run --rm worker claude auth login --claudeai
docker compose run --rm worker claude auth status
docker compose run --rm worker allin-worker doctor claude

Open the link shown in the terminal, sign in to Claude, then paste the returned code into the terminal if prompted. Wait for “Login successful”.

The claude-config volume stores the login and sessions. Keep it when recreating the container.

Worker Codex account

Sign in to the engine selected for your agents. For Codex, enable device code login in ChatGPT security settings, then open the link shown in the terminal.

docker compose run --rm worker codex login --device-auth
docker compose run --rm worker codex login status
docker compose run --rm worker allin-worker doctor codex

The codex-config volume preserves Codex authentication and sessions. It stays private and is never part of the published image.

Official documentation

GitHub for MCP tools and reviews

Jobs use the GitHub connection authorized in Allin. Update its credentials in Connections, then check enabled tools and those permitted on the agent profile.

Open Allin connections

• The account and token must have access to the relevant repositories. For a fine-grained token, select the correct resource owner and repositories.
• Contents: Read to read code. Pull requests: Read to read PRs and their files, Read and write to create or submit a review, including PENDING reviews.
• If required by the organization, obtain approval for the token or app and authorize its SSO access.

Reading code does not prove the token can read PRs or create reviews. Fix the permissions of the connection in use, then try reading the PR again. A successful read does not verify write access.

GitHub review permissions

The agent profile also lets you choose the model, reasoning effort, file access and subagents.

Check connection

The doctor command checks the engine and sign-in; doctor codex also executes real commands in the read-only and workspace-write sandboxes. No model or Allin API is called. The Connected badge in Allin confirms the worker heartbeat.

Connected does not mean every engine is available. In preview.4, a failed Codex startup check excludes that engine: Claude may run while Codex jobs remain queued. Check the logs and restart the worker after fixing the issue, once running jobs have finished.

Complete sign-in before starting. If the worker already has running jobs, wait for them to finish before restarting it.

docker compose up -d
docker compose logs --tail=50 -f worker

Once started, the worker can execute queued jobs using authorized accounts and tools. Allin MCP is configured automatically.

In Allin → Workers, check the Connected badge and assigned agents. Check each engine with doctor and the worker logs. Configure repositories on the worker page. A test job then validates the full flow, with your approval for its usage costs.

Codex on Ubuntu: host AppArmor restriction

On recent Ubuntu releases, apparmor=unconfined in Compose may not be sufficient. If bwrap reports “loopback: Failed RTM_NEWADDR: Operation not permitted”, check the host for unprivileged_userns profile denials for setpcap or net_admin. A successful unshare -U test does not validate the entire sandbox.

sysctl kernel.apparmor_restrict_unprivileged_userns kernel.apparmor_restrict_unprivileged_unconfined
sudo journalctl -k --since "10 minutes ago" | grep -Ei 'apparmor="DENIED"|userns'
docker exec WORKER_CONTAINER sh -c 'id; cat /proc/self/attr/current'
docker exec WORKER_CONTAINER codex sandbox -- true
docker exec WORKER_CONTAINER find /usr/local/lib/node_modules/@openai/codex -type f -path '*/codex-resources/bwrap'

Replace WORKER_CONTAINER with the actual container name. With Codex 0.160.0, use codex sandbox -- true, without adding linux. The worker must run as node (uid 1000). Check the bundled bwrap path before applying the profile below.

If the logs confirm this restriction, an administrator can install this targeted profile on the Ubuntu host, outside the container. It permits userns for the bwrap bundled with Codex; it does not disable the restriction across the host. This exception was validated with the preview.4 image on Ubuntu; recheck the path and diagnostics after an update.

abi <abi/4.0>,
include <tunables/global>
profile codex-bwrap /usr/local/lib/node_modules/@openai/codex/**/codex-resources/bwrap flags=(unconfined) {
  userns,
  include if exists <local/codex-bwrap>
}

sudo apparmor_parser -r /etc/apparmor.d/codex-bwrap
docker exec WORKER_CONTAINER codex sandbox -- true
docker exec WORKER_CONTAINER allin-worker doctor codex

After the checks pass and Codex is signed in, restart the worker once its running jobs have finished: available engines are detected at startup. Keep seccomp, cap_drop: ALL, no-new-privileges and the Codex sandbox. Document the AppArmor exception; do not globally disable the host userns restriction.

Official Codex sandbox documentation

Job files and persistent storage

Place repositories, documents and data shared between jobs under /workspace, backed by a volume in the official Compose. Use /tmp for temporary files. Access to paths under /home/node depends on the sandbox and permissions: do not use it for agent work documents.

Persistence and sandbox access are separate. A volume preserves files when the container is recreated, but does not grant Codex additional permissions. Files outside volumes are lost on redeployment. /home/node/.cache is not persistent in the official Compose.

services:
  worker:
    volumes:
      - worker-cache:/home/node/.cache
volumes:
  worker-cache:

Add this mount and volume declaration without replacing existing volumes. Back up any cache you need before recreating the container: a new volume does not recover data from the old container. Keep caches and authentication data private, never in a published image.

Updates and troubleshooting

Keep the volumes and the same worker when updating: they contain sessions and repositories. Do not use docker compose down -v, docker volume prune or docker commit on an authenticated container.

After rotating a key, replace ALLIN_WORKER_API_KEY in Coolify’s private variables and redeploy, or update .env and recreate the Compose container. A simple restart does not reload environment variables.

docker compose up -d --force-recreate

• Worker waiting: complete Claude Code or Codex sign-in in the correct container and its volumes.
• Worker offline or 401 error: check ALLIN_URL, the active worker key and network access from the server without exposing secrets.
• GitHub 403 error: check the account, allowed repositories, PR permissions and SSO approval. gh and the GitHub MCP use separate connections.
• Codex sandbox error: use the official Compose, its seccomp profile and apparmor=unconfined on a dedicated host. Recreate the container after jobs finish, preserving volumes, then run allin-worker doctor codex over SSH. Do not disable the Codex sandbox.