Try the demo image

What you'll accomplish: Run one self-contained Docker image and see a real 6-agent FNOL (First Notice of Loss) claims pipeline working end-to-end — no separate licence request, no manual package install, no registry or identity-provider setup.

What it is

hoziron-demo is a single Docker image bundling everything needed to see Hoziron work on a realistic claim, with nothing else to stand up:

• hoziron-server — the platform itself (API, registry, and dashboard surfaces)
• The Notional Mutual reference system of record — a simulated carrier back end (policy admin, claims core, notify) that the demo's FNOL pipeline reads from and writes to
• A bundled identity provider — a demo login is baked in, so the dashboard is usable immediately
• A small local model, used only for one narrow internal task (deciding which competency handles a request) — it never touches claim data or agent reasoning
• The fnol-claims-pipeline package, pre-installed — six agents (intake, validation, fraud-signal, severity, routing, resolution) already wired to the reference system of record, ready to run on the first claim

The FNOL agents themselves reason using your own Anthropic account — see Requirements below.

Requirements

• Docker
• Your own Anthropic API key. No key ships in the image or is provisioned by Hoziron — the FNOL agents run on the key you supply at docker run time. The container refuses to start without one, with a clear error telling you what's missing.

You do not need a separately-issued carrier licence for this image — a long-lived demo licence with no cloud spend attached to it is already baked in. (It grants zero Hoziron-managed cloud allowance; your Anthropic key is billed to your own account, not Hoziron's.)

Getting the image

There is no public hoziron-demo image to docker pull — ask whoever owns your Hoziron relationship for an image reference (<registry>/hoziron-demo:<tag>) and, if it's in a private registry, the credentials to pull it. The rest of this page applies once you have one.

1. Run the container

docker run -d --name hoziron-demo \
  -e ANTHROPIC_API_KEY="sk-ant-..." \
  -p 4200:4200 -p 4210:4210 -p 4300:4300 -p 5556:5556 \
  <your-image-ref>

Port set:

Add -v hoziron-demo-data:/data if you want the container's state (installed packages, any config edits) to survive a docker rm/recreate rather than just a docker restart.

2. First-run behaviour

On first boot, the container copies its baked-in config, PII policy, identity-provider config, and licence into /data (skipped on every later boot/restart against the same volume, so any edits you make survive). It then starts the reference system of record, the identity provider, and the local model, connects them to the pre-installed fnol-claims-pipeline package, and finally starts hoziron-server itself. This takes a few seconds — give it a moment before hitting the dashboard.

The reference system of record also runs a background claim-notice generator by default, so a claim will typically already be in flight — kicked off automatically via a webhook — shortly after the container comes up. You don't need to trigger anything by hand to see the pipeline run.

3. Log in

Open http://localhost:4200/dashboard and sign in through the bundled identity provider with the demo operator account:

• Username: demo
• Password: hoziron-demo

This account is intentionally public — it's scoped to this one freely-distributed demo image, not a credential worth protecting.

4. Reset demo state

To get back to a clean starting point between demo runs, without restarting the container:

docker exec hoziron-demo hoziron-demo reset --admin-url http://127.0.0.1:4300

This resets the reference system of record's data back to its seeded starting state.

What this image is not

• Not licensed for production use. The baked-in licence exists to make the demo self-contained, not to run real carrier traffic.
• Not a bundled/capped cloud budget. All FNOL reasoning runs against the Anthropic key you supply, billed to your own account.
• The local model is scoped narrowly. It only ever handles one internal routing decision — no FNOL agent, and no claim data, ever reaches it.

If something doesn't come up

Check the container's own logs first — the entrypoint logs each backgrounded component (identity provider, local model, reference system of record) as it starts:

docker logs hoziron-demo

If docker run exits immediately with a message about ANTHROPIC_API_KEY, that's the fail-fast check described in Requirements — supply the key and re-run.

Related:

• Install via Docker — the production image, for a real carrier deployment
• Your first agent