Files
zeekay fec2bdf0d1 The skills index lists a skill only when the site serves it whole; the build drops pages with no source
site.py now lists a SKILL.md under skills/ only when /<name>.md is that
file byte for byte and every file it points at by a relative path
(references/, scripts/, templates/, tools/, a sibling page) is published.
120 entries pointed at files the site does not serve, reference docs were
listed as skills, and 18 names served another file. 188 skills remain.
tests/discovery.py holds the published index to the same rule.

build.py deletes every page it did not write, except the hand-written
pages in KEEP, walks skills/ in name order so a shared name resolves the
same on every filesystem, and refuses to run without HIPS_DIR. Rebuilt
against hanzoai/hips main: the 40 discover-* pages and 20 HIPs whose
source is gone are removed, the stale code-review, engineering-code-review
and ml pages match their source, and 66 pages that were never built (60
skills among them) and 4 new HIPs are published. .gitignore anchors the root symlinks, so public/gemini.md is
not ignored on a case-insensitive checkout.
2026-10-29 21:28:54 -07:00

25 KiB

LLM.md - Hanzo Skills

Overview

A skill is a directory: {name}/SKILL.md says what it covers and names the files beside it. 224 skills, 1,103 markdown files covering the entire Hanzo AI ecosystem. 210 are ours; fourteen are Anthropic's, redistributed under Apache-2.0 — see NOTICE and the section below.

Company

Positioning, verbatim wherever it appears: "The AI operating system for business. Building business software since 2014. Techstars '17."

The source for Hanzo's history is the founder's account (owner override, 2026-10-26: the founder is the authority; there is no claim ledger). Print it in the company's voice, these numbers and no others:

  • Working since 2014. Founded as Crowdstart, a crowdfunding and commerce platform; renamed Hanzo in 2016.
  • First customer, 2014: SKULLY, the fastest fully-funded campaign on Indiegogo, $1M in about 45 hours (TechCrunch, 2014-08-14). Not "$1M on the first day": the source says 45 hours.
  • Go-native platform since October 2014: the first Go file in the commerce repo is from 2014-10-20; the 2014-09-29 first commit is a CoffeeScript prototype. Never "since day 1".
  • AI and machine learning in commercial use since 2014; GPT models by 2019.
  • 2017: the first blockchain-native commerce platform; the Unikrn ICO raised over 120,000 ETH (Crunchbase News, 2017-10-24, which does not name Hanzo; Hanzo's part is on https://hanzo.ai/customers#unikrn).
  • Techstars '17: https://hanzo.blog/2017-06-08-techstars-17/ (2017-06-08) and Startland News, 2017-10-10.
  • Clients funded by Y Combinator, 500 Startups, Techstars and other tier-1 firms: hundreds of venture-funded startups, billions in client revenue, two companies past 100 million users, two that went public on Nasdaq in 2024 (Damon Motorcycles, Triller). "Went public", never "IPO": neither listed by IPO.
  • What that portfolio taught is what Hanzo's AI is built on. Never say client data trained it.
  • First commit of the commerce platform: 2014-09-29.
  • Results, each printed with its source: Damon Motorcycles at CES 2020 ($8.4M sold in 30 days, 541:1 return on ad spend, 60,384 people reached on $329 before launch, every AI-generated ad set rated "Above Average" on Facebook within 36 hours, YouTube subscribers +3,752%; https://hanzo.ai/customers/damon-motorcycles); SKULLY ($1M in about 45 hours; TechCrunch); Unikrn (over 120,000 ETH; Crunchbase News). GPT-2 belongs to the founder's account on the about page only, never beside the case-study numbers.
  • People, as https://hanzo.ai/about states: CEO Antje Worring (https://www.linkedin.com/in/antje-worring/), CTO Zach Kelling (https://www.linkedin.com/in/zeekay/, https://github.com/zeekay). Nothing else about Antje.
  • Contacts: [email protected], [email protected] (sales), [email protected], [email protected] (investors), https://hanzo.ai/contact, https://cal.com/hanzo. Print no other address: one more alias on the domain has no reader. No support response time exists; promise none.

Not yet provable, and the artifact that would prove it:

  • "original AI OS", "first AI chat app", "LLM chat before ChatGPT": a dated public record (commit, archived page, press) older than what it is compared with. "First" is printed only where the owner dates it.
  • Hosted MCP in Claude Code: claude mcp get hanzo answering Connected against https://api.hanzo.ai/v1/mcp. Today Claude Code 2.1.310 refuses the server's protocol version, 2026-07-28.
  • The Zed MCP config: a Zed session listing the server's tools. Only the format was checked.
  • An agent's email-code sign-up end to end: one run from a test inbox to a minted key.
  • The campaign flow (event tag, draft, launch, metrics, pause): one run by a non-admin identity. It is read from cloud's OpenAPI at 93083f029, never executed; print no results for it.
  • A checkout method beyond card, Apple Pay and Google Pay: the live checkout offering it.

The hanzo skill

skills/hanzo/SKILL.md (name: hanzo, published as public/hanzo.md, installed with npx skills add https://hanzoskills.com/hanzo.md) onboards an agent. It leads with the owner's words, verbatim, in the description and the first line: "Sign up free with a wallet. Get an API key free. A small free allowance to try it. Top up in USDC or USDT over the API to raise your limits and pay as you go. No human required." Then Start: the headless path one request a step with its answer (nonce, sign, verify, token, key, limits, a 429, deposit, balance; in full at docs.hanzo.ai/docs/agents/headless) and the one TypeScript file run end to end on 2026-10-26, byte for byte hanzo-inc/app lib/agents.ts HEADLESS. Then the standard prompt verbatim, Why Hanzo and Results (the Company lines above), path A for a builder agent (other credentials, the free allowance, first call, MCP for Claude Code, Codex, Cursor and Zed, Kai evaluation, a campaign drafted for the owner to launch, rate limits), path B for an owner of agents (org, Team plan, bounded keys, per-session caps, paying, people), then where the rest is.

No wallet-allowance number: cloud is changing what a wallet-only account gets free, so the skill says "a small free allowance to try it" and points at GET /v1/allowance and GET /v1/billing/tier; 50 a day is printed only as a person's Free plan, and the run output's remaining count is elided. public/llms.txt opens its Hanzo block with the same words (scripts/build.py).

Republishing one skill without a full rebuild: a Linux scripts/build.py churns pages a macOS build wrote (see the site section), so build into a scratch OUT_DIR and copy only that skill's <name>.md, <name>.html, its row in llms.txt, index.md and index.html, and its section of all.md; then scripts/site.py until it rewrites 0 pages.

Every number in it comes from the 2026-10-26 measurement, which marked each line VERIFIED (ran it) or READ (code at a cited commit). Re-measure before changing one; add none from memory. It prints no bank numbers (GET /v1/billing/wire gives them to a signed-in caller) and no x402: x402 settles priced marketplace tools through POST /v1/tool/call, and is not a way to pay for chat or decisions.

The root skill.md also carries name: hanzo; a loader keyed on name keeps one of the two. It is the local-first manifest and sends onboarding to this skill.

Install

One skill, into any agent, with the skills.sh CLI. The first form fetches the page the site publishes and needs no GitHub access; the second clones this repository and copies skills/<name>/:

npx skills add https://hanzoskills.com/kai.md                 # asks for agents and scope
npx skills add hanzoai/skills --skill kai -a claude-code -y    # Claude Code, this project, no prompts

-g installs for the user instead of the project; --list shows every skill the clone can install. Verified with skills 1.7.0: the URL form anonymously against the live cloud-host.md and against kai.md served from a local build; the clone against github main, 224 skills found, kai written to .claude/skills/kai/SKILL.md, byte for byte the file in skills/kai/.

Claude Code also takes kai as a plugin of its own. .claude-plugin/marketplace.json lists it with "source": "./skills/kai", "strict": false and "skills": ["./"], so the plugin is that one directory and there is no second copy of SKILL.md:

claude plugin marketplace add hanzoai/skills
claude plugin install kai@hanzoai-skills

Verified on Claude Code 2.1.284: claude plugin details kai@hanzoai-skills lists one skill, kai, and the plugin cache holds only its SKILL.md. The hanzo-skills plugin ("source": "./", the whole repository) does not install there: .claude-plugin/plugin.json gives author as a string where Claude Code requires an object, and claude plugin validate . fails on it.

github.com/hanzoai/skills is private, so the clone and the plugin need GitHub access to it. Without that (no git credentials, gh login or SSH key) the clone fails with Authentication failed. The URL form takes any page the site publishes, https://hanzoskills.com/<name>.md; kai.md is served once the site deploys.

The Architecture (current truth)

Hanzo runs as ONE Go binary: hanzoai/cloud embeds IAM, KMS, o11y, tasks, notify, pubsub, kafka, console, and ai as clients/* plugins on zip (the ZAP-native server) behind the cloud.Register registry. Transport is ZAP only (HIP-0114) — zero gRPC, zero protobuf in Hanzo code (pb exists solely at the OTel edge via zap2pb). Storage is SQLite-primary per-tenant plus datastore (ClickHouse); coordination is Lux Quasar + zapdb — never ZooKeeper/raft/etcd. Deploy modes (HIP-0117): cloud serve (no k8s), cloud cluster init (k3s + operator CRs), helm install (BYO k8s). Canonical skill: skills/hanzo-cloud-architecture/SKILL.md. Full spec: HIPs 0106, 0114, 0116, 0117, 0004.

Structure

skills/
  skills/
    hanzo-cloud-architecture/  # THE architecture skill (read first)
      SKILL.md
    kai/                # building with Kai decisions; installs on its own (see Install)
      SKILL.md
    hanzo-api/          # product skills — how to CALL api.hanzo.ai; INDEX.md lists 121, ai, kms and sandbox are on disk
      INDEX.md          # every product, grouped into 13 domains
      <product>.md      # one per x-app: families, operations, real curls
                        # GENERATED: scripts/generate_hanzo_api_skills.py
                        # (source: https://api.hanzo.ai/v1/openapi.json)
    hanzo/              # 134 Hanzo ecosystem skills (flat markdown)
      INDEX.md          # Catalog and decision tree
      hanzo-k8s.md      # K8s infrastructure
      hanzo-deploy.md   # Deployment guide
      hanzo-platform.md # PaaS (Dokploy fork)
      hanzo-id.md       # Client auth flows — @hanzo/iam SDK (PKCE, one way)
      hanzo-iam.md      # IAM server — hanzoai/iam (clean rewrite; retired fork = iam-v1)
      hanzo-identity.md # On-chain DID (distinct product, not the IAM login)
      hanzo-kms.md      # Secrets (luxfi/kms MPC)
      hanzo-ingress.md  # Ingress (Traefik fork)
      hanzo-cloud.md    # THE unified one-binary cloud (HIP-0106)
      hanzo-console.md  # LLM observability (Langfuse)
      hanzo-chat.md     # Chat UI (LibreChat fork)
      hanzo-team.md     # Collaboration (Huly fork)
      hanzo-bot.md      # Multi-channel bot skill
      hanzo-mcp.md      # Model Context Protocol
      hanzo-zap.md      # ZAP — THE transport (HIP-0114) + DB bridge
      hanzo-o11y.md     # Observability (embedded o11y subsystem)
      ... (134 total)
    # 220 other skill directories (api, cloud, ml, etc.)
  commands/             # Custom commands
  scripts/              # Helper scripts
  tests/                # Test suite

The fourteen skills that are not ours

academy-guide, algorithmic-art, brand-guidelines, canvas-design, claude-api, discernment-nudge, frontend-design, internal-comms, mcp-builder, skill-creator, slack-gif-creator, theme-factory, webapp-testing and web-artifacts-builder come from github.com/anthropics/skills under Apache-2.0, merged at upstream 3b3fad96af16a10759d930941b4520ba0c40edae. They sit flat in skills/ like every other skill, each with the upstream LICENSE.txt beside its SKILL.md. That LICENSE.txt is load-bearing — the repository's MIT licence does not cover those directories. Never delete one to tidy up, and carry it through any move. NOTICE at the root is the attribution and lists the two frontmatter changes we made; THIRD_PARTY_NOTICES.md is Anthropic's, verbatim.

Re-syncing means copying the directory again and re-applying exactly two things: the license: frontmatter line, which upstream leaves unnamed, and claude-api's description, which upstream ships at 1068 characters against a 1024 cap that makes it unloadable as-is.

Five upstream skills are absent on purpose. docx, pdf, pptx and xlsx are source-available, not open source: their LICENSE.txt forbids copying them, keeping them outside Anthropic's services, deriving from them and distributing them, so merging them here would violate it four ways. doc-coauthoring ships with no LICENSE.txt and the upstream repository has no root licence, so nothing grants us the right — that one is a question for Anthropic rather than a settled no. Do not add any of the five because they look like a gap.

The site — hanzoskills.com

public/ is the site, byte for byte. It serves off the Hanzo Sites plane — an S3 prefix plus a host route, no pod, no image, no replicas. Cloudflare is DNS and CDN for the zone and nothing else: there is no Pages project, no Worker, and no Cloudflare credential anywhere in the lane.

public/          index.html + 1,244 <name>.html + <name>.md + all.md, llms.txt, favicon.svg, fonts/
scripts/build.py markdown->html generator: parses skills + core HIPs, formats index & categories
scripts/site.py  the shared chrome: style, nav, hero, copy-prompt menu, agent bar, Zen fonts
scripts/marks.py mark geometry, from hanzoai/design assets/{providers,logos}
scripts/webmcp.ts the WebMCP tools every page loads; `npm run webmcp` strips it to public/webmcp.js
tests/site.mjs   browser checks — mark, menu, bar, WebMCP tools, computed border-radius, Zen fonts
  • scripts/build.py compiles skills/ and the HIPs into public/: 1,252 documents on 2026-10-29. It deletes every top-level .md/.html it did not write, except the hand-written pages in KEEP (auth.md, and the moved notices hanzo-migrate-backend-to-go and ui-port-parity), so a page whose source is gone stops being served. The HIPs come from HIPS_DIR, whose default is a macOS path; anywhere else point it at a hanzoai/hips checkout at origin/main. The build refuses to run without it, since it would otherwise delete every HIP page. A name several files share (tool-use, streaming, batches, files-api, reference, experiments, affiliate-programs, and 18 hanzo-* skills shadowed by skills/hanzo/*.md) is published once, from the first file a name-ordered walk reaches, the same on every filesystem. A shadowed skill is left out of the skills index. Standards / HIPs are organized across 5 architectural domains explaining all standards: standards-core (Core AI & Models), standards-infra (Cloud & Native Infrastructure), standards-interface (Protocols & Realtime SSE), standards-security (IAM & Cryptography), and standards-apps (Platform & Applications). The hanzo category (led by hanzo-base, hanzo-cloud, hanzo-migrate-backend-to-go, hanzo-coursework-fullstack-go-cloud, hanzo-tutorial-realtime-sse-backend, hanzo-examples-native-cloud, hanzo-stack) is sorted first.
  • The site enforces native compiled code only (Go, Rust, C++), migrating away from Python/Next.js/Node/Rails/Java. Developers have a copy of the entire platform: run a local cloud (hanzo up cloud), extend with /v1/*, build on Hanzo Base (github.com/hanzoai/base) with realtime native Server-Sent Events (SSE), analytics, and insights, and scale to the full Hanzo AI Cloud (api.hanzo.ai, Zen qwen3+ only). Hanzo AI is Techstars '17.
  • Typography: Canonical Hanzo Zen and Zen Mono variable font families (public/fonts/Zen-Variable.woff2, Zen-Italic-Variable.woff2, ZenMono-Variable.woff2, ZenMono-Italic-Variable.woff2, ZenPixel-Square.woff2) loaded via @font-face with font-display: swap.
  • scripts/site.py is the ONE definition of the chrome and rewrites every page. It is idempotent, and CI fails if public/ does not match it. It writes each page's head: icon, canonical, <link rel="alternate" type="text/markdown" href="/<name>.md"> (/index.md for /, only where the twin exists) and the /webmcp.js module.
  • The home page opens on two boxes, from INSTALL, PASTE, NEXT and AFTER in scripts/site.py: the install command for the visitor's OS (tabs; every OS without JS) and the line to paste into an agent. site.py writes the same block into public/index.md. Windows is one INSTALL row once hanzo.sh/install.ps1 serves a script (404 on 2026-10-12).
  • Publishing is .github/workflows/deploy.yml on push to main, beside ci.yml. GitHub Actions runs both; each job is an ephemeral runner-github-skills-<id> pod that platform starts on the AWS cluster for the linux-amd64 label. It calls hanzoai/ci/.github/actions/site@v1, which is bin/site: enqueue → upload the objects straight to S3 → complete. The bytes never pass through the API. Do not publish by hand, and do not transcribe those three calls here.
  • GitHub Actions must be on for hanzoai/skills (gh api repos/hanzoai/skills/actions/permissions answers "enabled": true). It was found off with no recorded reason and turned back on 2026-10-26. Off, a push to main runs neither workflow and publishes nothing; the site only moved by hand-run bin/site publishes. The first runs back on found two more breaks, both fixed in deploy.yml: actions/upload-artifact@v3 fails the job at setup, and the browser checks must use the chromium the runner image bakes (playwright 1.58.0 at /opt/playwright) with no playwright install, which locks that unwritable directory before it checks anything.
  • ONE credential, KMS_CLIENT_ID/KMS_CLIENT_SECRET (org-level on git.hanzo.ai), which the action trades at kms.hanzo.ai for the deploy key.
  • Controls are pills (--r: 999px) and surfaces are --r-soft: 14px, matching hanzo.ai, whose buttons compute to a full pill at 44px tall.

Where the site lives, outside this repo

Two files in hanzo/universe, both on paths that self-heal:

charts/app/values/hanzo/static-sites.yaml   hanzoskills-headers + hanzoskills-static
                                            (root s3://hanzo-sites/hanzo/hanzoskills)
                                            and the apex ‖ www route
infra/k8s/ingress/wildcard-certs.yaml       *.hanzoskills.com + hanzoskills.com

Response headers are declared THERE, not here: staticFiles reads objects out of S3 and never a _headers file, so a header this site wants is a middleware or it does not exist. DNS is apex + www A -> 129.212.164.5, proxied.

The robots.txt in public/ is the one that is served, and that is the point of the move — the zone used to answer with a Cloudflare-managed file that named no crawler at all, on a site whose whole purpose is being read by agents. It is one group: * and every named crawler, one Content-Signal, Allow: /. A crawler reads only the group that names it, so a signal in the * group alone does not reach a named one. Bytespider is not named, as on hanzo.ai. ai-train=yes is the owner's call; it has not been re-decided here.

Content types

The 1,246 markdown files (the 1,244 page twins, index.md and all.md) are served text/markdown; charset=utf-8; .html, .txt, .xml and .svg carry their own types. Measured on the live host for index.md, hanzo-base.md, all.md and hip-0004.md.

scripts/build.py renders headings, lists, quotes, code and paragraphs. It has no table rule: a markdown table on a page arrives as one paragraph of pipes in the HTML, and intact in the .md twin.

Agent discovery (Cloudflare Agent Readiness)

What an agent finds the site and the API by. tests/discovery.py public [https://host] checks all four, before the publish and against the live host after it.

public/auth.md                             how an agent gets a credential for api.hanzo.ai (hand-written)
public/.well-known/api-catalog             RFC 9727 linkset: the API and the MCP endpoint (hand-written)
public/.well-known/mcp/server-card.json    MCP Server Card v1 for https://api.hanzo.ai/v1/mcp (hand-written)
public/.well-known/agent-skills/index.json Agent Skills Discovery 0.2.0, written by scripts/site.py
public/webmcp.js                           WebMCP tools, stripped from scripts/webmcp.ts (npm run webmcp)
  • The catalog's anchors: api.hanzo.ai/v1, its MCP endpoint, hanzoskills.com (llms.txt, skills index) and hanzo.ai/agents. Live, discovery.py fetches every link in it and fails on any non-200.

  • WebMCP: where the browser has document.modelContext (or navigator.modelContext), every page registers search_skills(query, limit) (every word must match name or description; name hits rank first) and get_skill(name) (the skill's markdown, refused unless its SHA-256 matches the index), both readOnlyHint. Elsewhere it does nothing. tests/site.mjs drives both through a recording modelContext; the deploy step fails when public/webmcp.js differs from a fresh strip.

  • The skills index lists a skill only when an agent can install it from the site whole: a skills/**/SKILL.md whose front matter names it <name> (lowercase, hyphens, at most 64) with a description of at most 1,024 characters, served byte for byte as /<name>.md, and every file it points at by a relative path (a link with a directory or extension, or a references/, scripts/, templates/, assets/, examples/, resources/, tools/ path) published beside it. 188 of the SKILL.md files on 2026-10-29; 90 wait on unpublished supporting files, 18 are shadowed. Reference docs and pages that are not a SKILL.md are never listed. site.py writes the index, and tests/discovery.py holds it to the same rule, so CI fails when they disagree.

  • Every claim in auth.md and the card was checked live on 2026-10-26 against the hanzo skill. Change them with it. The card is the MCP Server Card v1 shape and nothing more. A scan of it calls initialize and tools/list on https://api.hanzo.ai/v1/mcp, so every scanner that reads the card exercises that endpoint.

  • auth.md is read by keyword: a protocol named only to say it is not offered was scored as support, and a URL inside a code span was fetched with the closing backtick. Name no protocol token there, and write URLs as <https://…>.

  • Not on this host, on purpose: OAuth authorization server metadata and protected resource metadata (hanzoskills.com issues nothing and protects nothing; RFC 8414 3.3 and RFC 9728 3.3 tie each document to its own host: they live at hanzo.id and api.hanzo.ai), an A2A agent card (no A2A endpoint answers), Web Bot Auth (Hanzo's fetchers sign no requests).

  • The served type of /.well-known/api-catalog (no extension, so the plane sends none), the Link header on / and Accept: text/markdown on every page are the plane's: hanzo/universe sites.yaml.

Key Skills by Domain

Infrastructure

  • hanzo-k8s.md -- Two DOKS clusters: hanzo-k8s (prod, 22 nodes) and lux-k8s (blockchain)
  • hanzo-deploy.md -- Universe repo is source of truth. main=prod, dev=staging
  • hanzo-ingress.md -- Traefik fork, IngressClass hanzo, auto TLS
  • hanzo-static.md -- Traefik static plugin, replaces nginx/caddy

Identity & Security

  • hanzo-id.md -- RFC 6749/OIDC, multi-org (hanzo/lux/zoo/pars), Cloudflare Worker
  • hanzo-kms.md -- KMSSecret CRDs for K8s sync, 9 Vault subsystems
  • hanzo-zt.md -- Zero-trust (OpenZiti fork), dark services, mTLS

AI Services

  • hanzo-cloud.md -- THE unified one-binary cloud (HIP-0106); ai subsystem = provider mgmt
  • hanzo-skill.md -- HIP-0004 unified AI provider interface at api.hanzo.ai, BYO keys
  • hanzo-console.md -- LLM traces, costs, prompts + per-product metering, 402 balance-gating
  • hanzo-chat.md -- Multi-model chat UI (14 Zen + 100+ third-party)
  • hanzo-mcp.md -- 260+ tools, 13 HIP-0300 unified tools
  • hanzo-bot.md -- 50+ messaging adapters, ACP skill

Data

  • hanzo-zap.md -- ZAP: THE transport (HIP-0114) + SQL/KV/Datastore/DocumentDB→MCP bridge
  • hanzo-o11y.md -- Infrastructure APM, embedded in cloud; ClickHouse keeper-free, OTLP-over-ZAP

Hard Rules

  1. ONE binary, ZAP only -- no gRPC, no protobuf in Hanzo code (pb only at the OTel edge via zap2pb)
  2. KMS for all secrets -- never plaintext in manifests
  3. GHCR for images -- ghcr.io/hanzoai/*, --platform linux/amd64; never mix with ghcr.io/luxfi/*
  4. Kustomize, not Helm (exception: cloud/helm/cloud for BYO-k8s installs)
  5. No nginx, no caddy -- Hanzo Ingress only
  6. CI = GitHub Actions on platform's ephemeral cluster runners (linux-amd64); no GH-hosted builders
  7. IAM for all auth -- RFC 6749 endpoints, implicit flow preferred
  8. Universe repo is source of truth for K8s manifests; operator reconciles services.hanzo.ai CRs
  9. SQLite-primary per-tenant; PostgreSQL only for prod multi-instance; never default to PG locally
  10. Quasar + zapdb for coordination -- no ZooKeeper, no raft, no etcd
  11. Zen models: qwen3+ only, never reference upstream names
  12. luxfi packages only, never go-ethereum or ava-labs
  13. compose.yml not docker-compose.yml

Production Topology

8 Kubernetes clusters operated; visor autoscales fleets across providers. Post-consolidation, the standalone notify/tasks/o11y/pubsub/... pods are retired — they run as subsystems inside the cloud binary. The surviving distinct surfaces:

hanzo-k8s (do-sfo3-hanzo-k8s, LB: 165.232.146.176)
  +-- cloud (ONE binary: IAM/KMS/o11y/tasks/notify/pubsub/kafka/console/ai)
  |     hanzo.id, kms.hanzo.ai, console.hanzo.ai, o11y.hanzo.ai, ...
  +-- Gateway (api.hanzo.ai -- HIP-0004 unified AI interface)
  +-- Chat (chat.hanzo.ai), Team (hanzo.team), Bot, DNS, ZT, ...
  +-- SQLite per-tenant (in-binary) + PostgreSQL for multi-instance
  +-- datastore/ClickHouse (telemetry, keeper-free)
  +-- Valkey (redis.hanzo.svc), MinIO (minio.hanzo.svc)

lux-k8s (do-sfo3-lux-k8s, LB: 24.144.69.101)
  +-- validators
  +-- Gateway (api.lux.network)
  +-- Markets, Cloud (white-label of the same binary)