Skip to content

Release notes 0.1.0

First release, tagged 2026-10-09. Multihull deploys one container to Kubernetes and Modal from one multihull.yaml, serves both behind one URL through a Rust router, and fails over between them per request.

Scope of 0.1.0, plainly: a Kubernetes plus Modal failover router for a single model. Not yet the five-provider framework the architecture plan describes.

Terminal window
uv tool install multihull==0.1.0
cargo install multihull --version 0.1.0
helm pull oci://ghcr.io/mishraprafful/charts/multihull --version 0.1.0

Images: ghcr.io/mishraprafful/multihull-router:0.1.0, multihull-controller:0.1.0, multihull-mock-server:0.1.0. The GitHub release carries router binaries for linux amd64, linux arm64 and macOS arm64. The GHCR images and chart are public since 2026-10-09 and pull anonymously; see Install from OCI. PyPI and crates.io packages are public.

  • One spec: hull init, plan, deploy, status, logs, destroy. hull plan renders every provider’s native payload to .multihull/plan/ before anything is applied.
  • Kubernetes and Modal translators with digest-pinned images, so failover lands on byte-identical containers.
  • Router: priority spillover, endpoint and provider circuits, active probes, retry before the first committed byte with a per-route budget, admission queue, sticky routing, SSE passthrough with a terminal error event on upstream loss, TLS, Prometheus metrics.
  • hull controller: streams snapshots to routers over TLS, reacts to Degraded signals by raising warm replicas, persists raised floors and snapshot versions in SQLite, runs in the cluster from the Helm chart.
  • Route API keys that never reach the snapshot in plain text and fail closed when the key source is empty.
  • Docker translator and a mock model server, so the whole failover path runs on a laptop or a CI runner with no GPU and no cloud credentials.

Proven by real runs:

  • Per-request failover between a Kubernetes primary (kind) and a Modal secondary running the mock server on CPU: about 1,400 requests and zero client errors while the primary scaled to zero, across several green live smoke runs.
  • On every PR: the local e2e suite (36 rows), the kind suite (27) and the in-cluster suite (controller and router in kind over TLS, controller restarts with kept and wiped state).
  • Deploy to Kubernetes and Modal from one spec with digest-pinned images.
  • A real model on GPUs: two consecutive live GPU runs on main (37821488815, 37822124427, live-gpu.yml, #49) deployed Qwen/Qwen2.5-1.5B-Instruct on vLLM 0.11.0 to two Modal L4 targets, streamed tokens over SSE and plain completions, stopped the primary app and served every failover request from the secondary with zero client errors (23 requests per run). Deploy reached Ready in about 100 s with the image cached; vLLM listens about 75 s after container start.

Not proven:

  • Kubernetes with a GPU: kind has no GPUs, so node selectors and tolerations have never scheduled on a real cluster, and no real model has run on Kubernetes.
  • A cluster pull from a private registry.
  • RunPod, Baseten and Replicate are render-only: hull plan works, apply raises not implemented.
  • Only SQLite state exists. s3://, gs:// and postgres:// exit with a not-implemented error.
  • No sustained load or multi-replica router measurements. The plan’s latency and throughput numbers are targets, not results.
  • The chart ships no RBAC for the controller.
  • Nothing has been installed from the published chart.
  • No outside user has run hull init through hull deploy.

Most of this code was written by coding agents over a few days and reviewed by CI and other agents. Test coverage is strong where tests exist. A human read-through of the router’s retry and circuit paths (router/crates/multihull/src/proxy/handler.rs, core/circuit.rs, core/retry.rs) is recommended before relying on it in production.

Nothing to upgrade from. Two names changed before the tag and may be in early configs:

  • Log filters name multihull::proxy, not router_proxy. Update [log] filter in router.toml and RUST_LOG.
  • The controller image is ghcr.io/mishraprafful/multihull-controller.
  • --state on every state-opening hull command, defaulting to MULTIHULL_STATE_BACKEND.
  • Controller TLS flags --tls-cert, --tls-key, --client-ca, --token-env, --insecure; router [snapshot] keys ca, client_cert, client_key, token_env, insecure. See Controller stream.
  • Router [pressure] ttft_rebaseline_after.
  • Chart values router.tuning, router.extraConfig, router.snapshot.tls, router.snapshot.token, router.snapshot.insecure, controller.image, controller.tls, controller.token, controller.insecure, controller.stateBackend, controller.envFrom.
  • RunPod, Baseten and Replicate: render-only.
  • State: SQLite only.
  • Chart: no controller RBAC, no kubeconfig mount for targets in other clusters.
  • hull failover test, hedging, cost-aware placement and per-key rate limits are planned, not built.
  • The router keeps serving its last snapshot on control-plane loss, but no metric or alert reports snapshot age yet.

Full list of changes: CHANGELOG.md.