ARNIE ships as certified container images from the Red Hat Ecosystem Catalog. Pull them, wire them together, and reach the interface. This guide walks the full deployment, start to finish.
ARNIE runs as three certified container images that work together:
| Image | Role | Port |
|---|---|---|
arnie-ai-granite | Bundled local model server (Granite via Ollama) | 11434 |
arnie-ai-backend | The RMCP engine — generates, governs, executes | 8085 |
arnie-ai-ui | The web interface | 8080 |
They run on any OCI-compatible container host — Podman or Docker. The examples below use podman; substitute docker if that's your runtime — the commands are identical.
To run ARNIE and use its full capabilities, you'll want:
| A container host | Podman or Docker, on a machine ARNIE's services can run on |
| A PostgreSQL database | For accounts, licensing, and usage — its connection string is passed to the backend |
| Ansible Automation Platform | Executes ARNIE's approved playbooks (optional — connect in settings) |
| A GitHub repository | Stores approved changes as the source of truth (optional) |
| A cluster | Where approved changes are applied live (optional) |
ARNIE is deployment-flexible — it runs standalone on a network, or inside a cluster. AAP, GitHub, and cluster connections are configured in the app's settings after install, and can be added when you need them.
Pull all three certified images from the registry:
podman pull docker.io/brandonjuimperbinvictus/arnie-ai-granite:1.0.0
podman pull docker.io/brandonjuimperbinvictus/arnie-ai-backend:1.0.5
podman pull docker.io/brandonjuimperbinvictus/arnie-ai-ui:1.0.7The Granite image is large (~7 GB) — the IBM Granite model is baked in, so nothing is downloaded at runtime and inference stays entirely on your infrastructure. The first pull takes a while; it only happens once.
Put the containers on a shared network so they can reach each other by name:
podman network create arnie-netStart Granite first — the backend connects to it for local inference:
podman run -d --name arnie-granite \
--network arnie-net \
docker.io/brandonjuimperbinvictus/arnie-ai-granite:1.0.0Give it a few seconds to load the model, then confirm it's serving:
curl http://localhost:11434/api/tagsYou should see granite3.1-dense:8b in the response.
Start the RMCP engine, pointing it at Granite and your database:
podman run -d --name arnie-backend \
--network arnie-net \
-e OLLAMA_BASE_URL=http://arnie-granite:11434 \
-e DATABASE_URL="postgresql://USER:PASSWORD@HOST:PORT/DBNAME?sslmode=require" \
-e ARNIE_JWT_SECRET="your-long-random-secret" \
-p 8085:8085 \
docker.io/brandonjuimperbinvictus/arnie-ai-backend:1.0.5The environment variables:
OLLAMA_BASE_URL | Where the backend finds Granite — use the container name on the shared network |
DATABASE_URL | Your PostgreSQL connection string |
ARNIE_JWT_SECRET | A long random string used to sign auth tokens — keep it secret and consistent |
Confirm it's healthy and connected to the model:
curl http://localhost:8085/healthThe response reports the selected model and engine status.
Start the web interface on the same network:
podman run -d --name arnie-ui \
--network arnie-net \
-p 8090:8080 \
docker.io/brandonjuimperbinvictus/arnie-ai-ui:1.0.7Open the interface in your browser at the host and port you mapped:
http://YOUR_HOST_IP:8090On the machine itself, that's http://localhost:8090. From another machine on the network, use the host's IP address. Sign up, sign in, then connect your integrations (GitHub, AAP, cluster) from Settings — and make your first request in plain language.
Prefer to bring everything up at once? Save this as compose.yaml and run podman compose up -d (or docker compose up -d):
services:
granite:
image: docker.io/brandonjuimperbinvictus/arnie-ai-granite:1.0.0
container_name: arnie-granite
networks: [arnie-net]
backend:
image: docker.io/brandonjuimperbinvictus/arnie-ai-backend:1.0.5
container_name: arnie-backend
depends_on: [granite]
environment:
OLLAMA_BASE_URL: http://arnie-granite:11434
DATABASE_URL: "postgresql://USER:PASSWORD@HOST:PORT/DBNAME?sslmode=require"
ARNIE_JWT_SECRET: "your-long-random-secret"
ports: ["8085:8085"]
networks: [arnie-net]
ui:
image: docker.io/brandonjuimperbinvictus/arnie-ai-ui:1.0.7
container_name: arnie-ui
depends_on: [backend]
ports: ["8090:8080"]
networks: [arnie-net]
networks:
arnie-net:
driver: bridgeFor anything beyond local use, put ARNIE behind a reverse proxy (nginx, Caddy, or your ingress) to give it a real domain and HTTPS. Point the proxy at the UI on port 8090 and the backend on 8085. A tool like Caddy will provision a Let's Encrypt certificate automatically for a domain you own.
Keep secrets out of images. The DATABASE_URL and ARNIE_JWT_SECRET are passed at run time as environment variables — never bake them into an image or commit them to source control.
Inside a container, localhost refers to that container — not another one. The backend reaches Granite by its container name on the shared network, which is why OLLAMA_BASE_URL is http://arnie-granite:11434, not localhost. Make sure all three containers are on arnie-net.
If port 11434, 8085, or 8090 is taken (for example, a local Ollama already using 11434), map a different host port — e.g. -p 11435:11434 — and point the backend at the container name rather than the host port.
The UI reads account and usage data through the backend and the billing service. Confirm the backend is healthy (/health returns OK) and that DATABASE_URL is correct and reachable from the backend container.
That's a cached session — you're already logged in. Open a private/incognito window to see the sign-in page, or clear the site's local storage.
The model server needs a few seconds to initialize after the container starts. Wait, then retry curl http://localhost:11434/api/tags. If it persists, check the container logs with podman logs arnie-granite.
ARNIE is part of the BLCKBX platform — certified and live on the Red Hat Ecosystem Catalog. Let infrastructure run by conversation.