Skip to content

Get palaia running

palaia lives on an always-on box that your AI tools reach from anywhere — a small cloud server, a NAS, a spare mini-PC. The simplest way to set it up is to let an AI assistant do it for you; every do-it-yourself path is below.

Let your AI set it up

You do not have to touch a terminal. Copy the prompt below, paste it into an AI assistant you already use, and it reads the setup guide and walks you through it — one step at a time, in plain language.

Paste this into your AI assistant

Set palaia up for me. First read all of get.palaia.ai/skill — if you can run commands, use curl, since a web fetch may only give you a summary. Then walk me through it step by step — I'm not technical, so explain everything simply.

Works inClaudeChatGPTGemini

The assistant asks where palaia should run and does the rest.

Rather set it up yourself?

All of these end at the same hub. The cloud-server path needs no terminal; the rest are for people comfortable with a command line or Docker.

A cloud server in three steps

No terminal, no SSH. You paste one file when you create the server and it sets itself up. Any small provider works — Hetzner Cloud and DigitalOcean are good, inexpensive picks; the smallest size is plenty.

  1. Start creating a server

    Sign in to your provider and begin creating a new server (a "Cloud Server" or "Droplet"). Pick any recent Ubuntu or Debian image and the smallest size — leave the page open at the step where it offers a Cloud config or User data field. That field is where the file in step 3 goes.

  2. Make up a setup code

    palaia joins a tailnet — a small private network of just your own devices (via Tailscale, free for personal use), so your hub is reachable from your phone and laptop but never from the open internet. You need a free Tailscale account and the Tailscale app on the device you will use. No key to create: just make up a setup code of 12 letters and digits, like K7QM-R2XD-9FTP. You type it once, on palaia's setup page.

  3. Paste this file, fill in your code, create the server

    Copy the file below into the provider's Cloud config / User data field. Change the one line it marks — PALAIA_SETUP_CODE="setup-code-REPLACE_ME" near the top — to your code from step 2. Nothing else needs editing. Then create the server.

    #cloud-config
    # palaia v3 — VPS install (SPEC-601). Paste this whole file into your
    # provider's server-creation user-data field — Hetzner Cloud calls it
    # "Cloud config", DigitalOcean calls it "User data" — then create
    # the server. Everything below runs itself: no terminal, no SSH session
    # needed to finish setup.
    #
    # ONE THING TO EDIT — find this line further down and replace the
    # placeholder with a setup code of your own (12 letters/digits, e.g.
    # K7QM-R2XD-9FTP; your AI assistant can make one up for you):
    #
    #     PALAIA_SETUP_CODE="setup-code-REPLACE_ME"
    #
    # A few minutes after the server starts, open http://<server-address>:8420/,
    # enter that code and click "Connect with Tailscale" — the server joins your
    # private network (tailnet). The same page then offers cloud access for
    # ChatGPT and Claude, and closes itself (SPEC-605).
    #
    # Prefer a key? Instead fill in the TAILSCALE_AUTH_KEY line below with an
    # auth key from https://login.tailscale.com/admin/settings/keys; then no
    # setup page is shown. Use a one-time key: it also stays in the provider's
    # copy of this file. Nothing else in this file needs to change.
    #
    # What it does: runs palaia's installer (https://get.palaia.ai/install, the
    # same script as `curl -fsSL https://get.palaia.ai | sh`), which installs
    # Docker and Tailscale, joins your tailnet, switches the firewall on (SSH
    # stays open) and starts the hub bound to the tailnet address only — so the
    # hub is never reachable from the public internet, only from your own
    # devices. See v3/deploy/README.md's "Cloud-init" section for what the data
    # volume holds and how to back it up or move it.
    #
    # This runs once per server — cloud-init's own rule. Running it again by
    # hand (`sudo sh /opt/palaia/cloud-init-setup.sh`) is safe: the installer
    # keeps your data and changes nothing that is already in place.
    #
    # Everything this does is also logged to /var/log/cloud-init-output.log —
    # check there first if the hub does not come up.
    package_update: true
    packages:
      - ca-certificates
      - curl
      - python3
      - ufw
    write_files:
      - path: /opt/palaia/cloud-init-setup.sh
        permissions: "0700"
        owner: root:root
        content: |
          #!/bin/sh
          # Written by cloud-init.yaml — see that file for the one thing to
          # edit. Safe to run again: the installer keeps what is already done.
          set -eu
    
          log() { echo "palaia cloud-init: $*"; }
    
          PALAIA_SETUP_CODE="setup-code-REPLACE_ME"
          TAILSCALE_AUTH_KEY="tskey-REPLACE_ME"
          INSTALLER_URL="https://get.palaia.ai/install"
    
          # Which way to join the tailnet: a filled-in key wins; otherwise the
          # setup page with the filled-in code. The checks below look only for
          # the marker word, so a copy where every placeholder was replaced
          # still passes them.
          USE_KEY=1
          case "${TAILSCALE_AUTH_KEY}" in *REPLACE_ME*|"") USE_KEY=0 ;; esac
          if [ "$USE_KEY" = "0" ]; then
              case "${PALAIA_SETUP_CODE}" in
                  *REPLACE_ME*|"")
                      log "ERROR: edit this file's PALAIA_SETUP_CODE (or TAILSCALE_AUTH_KEY) before pasting it."
                      exit 1 ;;
              esac
          fi
    
          # --- Run the installer ----------------------------------------------
          log "downloading the installer from ${INSTALLER_URL} ..."
          curl -fsSL --retry 5 --retry-delay 5 "${INSTALLER_URL}" -o /opt/palaia/get-palaia.sh
          # The key goes into a file only root can read — only now, once the
          # installer is here to delete it again: it hands the key to Tailscale
          # as `--auth-key=file:...` (never a command-line argument) and removes
          # the file however it ends.
          if [ "$USE_KEY" = "1" ]; then
              ( umask 077 && printf '%s' "${TAILSCALE_AUTH_KEY}" > /root/.palaia-tskey )
              export PALAIA_TSKEY_FILE=/root/.palaia-tskey
          fi
          export PALAIA_SETUP_CODE
          # A server created for palaia: switch ufw on (SSH stays open).
          export PALAIA_FIREWALL=on
          log "running the installer ..."
          sh /opt/palaia/get-palaia.sh </dev/null
    
    runcmd:
      - [sh, /opt/palaia/cloud-init-setup.sh]

    A few minutes after the server boots, open http://<server-address>:8420/, enter your code, click Connect with Tailscale and log in. The page shows your hub's private address — usually http://palaia/ — and then closes itself for good. If it does not come up, the server's /var/log/cloud-init-output.log has the full log of what ran.

Already have a server? One command over SSH

The file above only runs on a server's first boot, so pasting it into a box that is already running does nothing. For a server you already have, SSH in and run this one line — the installer sets up Docker, Tailscale, the tailnet-only firewall and the hardened hub, then opens the same one-time setup page and prints its address and code:

curl -fsSL https://get.palaia.ai | sh

Or a machine you already own

The developer options below install the same hub on any of these:

  • Raspberry Pi or another small always-on box — works today with 64-bit Raspberry Pi OS and Docker installed, then the Docker command below. A flash-and-boot card image that skips even those steps is planned and tracked in the open.
  • Synology NAS — its Container Manager runs a Compose file as a "project"; no terminal on the NAS itself. See the step-by-step Synology walkthrough.
  • Mac or Windows — install Docker Desktop once, then the Docker Desktop command below is the whole install. (Best for trying palaia out — for everyday use a box that stays on wins.)

For developers: Docker & Compose

Already run containers? Install the hub straight from the image.

One command

On a Linux machine with Docker Engine (a home server, a NAS, a Raspberry Pi), this is the whole install — palaia then answers at http://palaia.local:8420/ from every device on your network:

docker run -d --name palaia \
  --network host -e PALAIA_CLOUD_BIND=127.0.0.1 \
  -v palaia_home:/data \
  --restart unless-stopped \
  --security-opt no-new-privileges:true --cap-drop ALL \
  --read-only --tmpfs /tmp --tmpfs /run \
  ghcr.io/byte5ai/palaia:stable

With Docker Desktop on macOS or Windows, use this one instead and open http://localhost:8420/ on that computer — from inside Docker Desktop a name like palaia.local cannot reach your network:

docker run -d --name palaia \
  -p 8420:8420 \
  -v palaia_home:/data \
  --restart unless-stopped \
  --security-opt no-new-privileges:true --cap-drop ALL \
  --read-only --tmpfs /tmp --tmpfs /run \
  ghcr.io/byte5ai/palaia:stable

Want a script that installs Docker and Tailscale for you and prints the address at the end? That is the one command over SSH above — curl … get.palaia.ai | sh.

A file you keep

Prefer a config file you can edit and check in, or already run other containers this way? Clone the repository and start it with Compose:

git clone https://github.com/byte5ai/palaia.git
cd v3/deploy && docker compose up -d

A ready-to-use docker-compose.yml ships in that repository at v3/deploy/ — nothing to write yourself.

Self-hosting app stores

Packages for these platforms are built and kept current in the repository, but none is listed in an official app catalog yet — a submission step still to happen, tracked in the open. Until a listing goes live, Docker or Compose above install the same image on any of them, since they all run containers underneath.

Then open your hub

On a cloud or SSH setup, open the address the setup printed when it finished — usually http://palaia/ — from any device on your tailnet. On a Linux machine on your own network, open http://palaia.local:8420/ from any device there — or, if that name does not resolve (some networks block it; see Install it), the http://<host>:8420 address printed to the container's own log, which always works. With Docker Desktop, open http://localhost:8420/.

The wizard takes over

From there palaia's setup opens in the browser by itself: how you'll use palaia, your first memory, your account, cloud access for ChatGPT and Claude if you want it, and your first AI app — no file editing, no extra commands. See Your first shared memory for what that looks like end to end, or Install it for the longer version of everything on this page.