Install with Docker

Set up Umpteenth on one host with Docker Compose, from an empty directory to a signed-in instance with a working model. This setup keeps its SQLite database and its files in ./data next to the compose file, so you need no database server. On a Kubernetes cluster, install the Helm chart instead.

Requirements

• A host with Docker Engine and Docker Compose on amd64 (x86-64) or arm64.
• An Anthropic API key, or an OpenAI-compatible API such as OpenAI, OpenRouter, Ollama or LM Studio.

Set up

1. Create a directory for Umpteenth and a docker-compose.yml in it.

   mkdir umpteenth && cd umpteenth

   docker-compose.yml

   services:
     umpteenth:
       image: ghcr.io/stonith404/umpteenth:latest
       container_name: umpteenth
       restart: unless-stopped
       ports:
         - "8080:8080"
       volumes:
         - ./config.yml:/app/config.yml:ro
         - ./data:/app/data
         - /var/run/docker.sock:/var/run/docker.sock

   Umpteenth creates each run’s sandbox through the Docker socket.

2. Generate an encryption key of at least 16 bytes.

   openssl rand -base64 32

   Umpteenth encrypts your secrets, model API keys and MCP logins with the key and signs sessions with it. Keep a copy with your backups: under a different key, Umpteenth can’t decrypt what it stored, and everyone has to sign in again.

3. Pick how you sign in.

   Umpteenth has no passwords, and passkeys work without any setup. To sign in through an identity provider or with GitHub instead, register Umpteenth with it as Sign-in shows, and come back with a client ID and a client secret.

4. Create config.yml next to docker-compose.yml, with the key and any provider.

   Passkeys

   config.yml

   app:
     url: http://localhost:8080
     encryption_key: "<the key from step 2>"

   OpenID Connect

   config.yml

   app:
     url: http://localhost:8080
     encryption_key: "<the key from step 2>"
   
   auth:
     providers:
       pocket-id:
         type: oidc
         name: Pocket ID
         issuer: https://id.example.com
         client_id: "<client ID>"
         client_secret: "<client secret>"

   GitHub

   config.yml

   app:
     url: http://localhost:8080
     encryption_key: "<the key from step 2>"
   
   auth:
     providers:
       github:
         type: github
         name: GitHub
         client_id: "<client ID>"
         client_secret: "<client secret>"
         allowed_users: [octocat]

   app.url is the address you open Umpteenth at, which passkeys are bound to and your sign-in provider sends you back to:

   • On the machine that runs Docker, keep http://localhost:8080.
   • From another computer on your network, use the host’s address, such as http://192.168.1.10:8080, and sign in through a provider, since browsers refuse passkeys on plain HTTP away from localhost.
   • On a server that others reach, set its HTTPS address, such as https://umpteenth.example.com, and set up the reverse proxy before you sign in. With an https:// address, Umpteenth marks the session cookie as Secure, so a sign-in over plain HTTP on port 8080 fails.

   Everyone who signs in joins your workspace, with every job and secret in it. Passkey accounts come only from you once you have yours, a github provider admits only the accounts you list, and Sign-in shows how to limit an identity provider to a group.

   Every other option has a default, which Configuration lists.

5. Start Umpteenth.

   docker compose up -d

   On its first start, Umpteenth pulls the default sandbox image, ghcr.io/stonith404/umpteenth-sandbox:latest, which takes a moment. The log shows Server listening once Umpteenth is up:

   docker compose logs umpteenth

   A missing or invalid option stops the start with an error that names it, such as app.encryption_key (APP_ENCRYPTION_KEY) is required.

6. Open app.url in your browser.

   The login page reads Set up Umpteenth. Enter your Name and click Create account with a passkey, or click your provider’s button, such as Sign in with Pocket ID.

   As the first to sign in, you own the workspace, and the Dashboard shows Nothing to show yet until your first job runs. If sign-in fails, the login page shows the reason.

Before you open it up

The Docker socket gives Umpteenth root access to the host. Read Security before you run jobs you didn’t write, and put Umpteenth behind HTTPS with a reverse proxy before anyone else signs in.

Connect a model

A fresh instance has no model providers, so jobs have nothing to run on until you add one.

1. Open Settings → Providers & models and click Add provider. Keep the Anthropic kind, paste your key into API key and click Add provider.

2. Click Test on the new row, pick a model and click Send test prompt. Replied in with the model’s answer means the key works, and Failed after shows the provider’s error.

3. Open Settings → General, pick a model for Agent under Default models, such as Claude Opus 5.5, and click Save. A cheaper Utility model, such as Claude Haiku 4.5, compiles jobs and checks results for less, and without one the Agent model does that work.

For another provider, choose OpenAI-compatible in step 1 and enter its Base URL. Models and costs explains the model roles and how to connect a local server such as Ollama. To run jobs on your Claude or ChatGPT plan in place of an API key, follow Claude Code and Codex subscriptions.

Next steps

Your instance is ready for your first job. To make it reachable for others over HTTPS, continue with Reverse proxy.