Skip to content
Try Hanzo
Language: English (United States)

The AI‑nativecloud.

Hanzo Platform

Run models, agents, applications, data and infrastructure through one operating plane.

Kubernetes-native. Fully observable. Open source. Run it on Hanzo infrastructure or infrastructure you control.

$ docker run -p 8080:8080 ghcr.io/hanzoai/cloud
  • 400+ callable models
  • GPUs
  • Functions
  • Containers
  • Databases
  • Observability
  • One API
Select a layer

One stack.Down to the kernel.

The native AI stack

Build with agents. Route with Enso. Reason with Zen. Decide with Kai. Run on infrastructure you control.

API01—02

MIND03—05

95.6% on GPQA Diamond

ACT06—07

3.02× faster coding

RUN08—09

SILICON10—11

Hanzo / architecture map01—11 / owned and connectedInteractive drawing · not telemetryZAP / native interconnectAgent ↔ tool RPC · MCP bridge · typed service communicationProtocolSource

Explore the platform.

Every plane, and what is in it.

One runtime for every kind of work.

The same plane, held for a millisecond or for a month. What changes is how much of a machine the work needs, not what you have to learn.

  1. FunctionsScale to zero between calls.
  2. ContainersYour image, deployed and addressable.
  3. SandboxesIsolated shells for agents and untrusted code.
  4. MachinesA whole machine, by the second.
  5. GPUsAccelerators attached to any of them.
  6. KubernetesThe substrate all of it runs on.

The data primitives AI applications use.

Each primitive is the right shape for its job, and they share one project, one key and one bill.

One control plane. Any infrastructure.

The API, the console, the identities and the bill stay the same when the machines underneath change.

Security is part of the cloud, not a product on top of it.

An agent gets an identity because it runs here, and the trail is written because every call goes through the same door.

Push code. Get a production system.

An address, a certificate, secrets, metrics, logs and its share of the bill come back with it, because none of them is a separate purchase.

Pay for what runs.

Nothing is billed for existing. One organization balance and one usage ledger, and every line traces back to a request.

Containers — Hanzo

Deploy an image and invoke it. Deployments, triggers, secrets, metrics and logs are all part of the same surface, so a function you ship is a function you can watch.

  • gatewayReadyEvery request enters here, so the limiter does too.
  • payments-apiReadyThe service the session above is changing.
  • checkout-webBuildingA build is running from the last commit on main.
  • docs-siteReadyStatic, published by the same pipeline as the rest.

api.hanzo.ai/v1/functions

Open in the consoleExample project. Every name in it is one you would give your own.
Control planeAPI · console · identities · bill
  • Hanzo Cloud

    Capacity we operate and meter, provisioned by the call.

  • Your cloud account

    Your credentials and your machines, under the same control plane.

  • Your cluster

    Attach Kubernetes you already run and address it like any other.

  • IdentityOne issuer for people, programs and agents, each request scoped to the org it acts for.
  • PermissionsAccess follows the resource, not the caller.
  • SecretsHeld in KMS and handed only to the environment that needs them.
  • AuditActions written to a trail you can query, attributable to whoever took them.
  1. Push

    A commit to the forge starts the build.

  2. Build

    The image is built in the cluster, never on a laptop.

  3. Release

    It rolls out with its secrets and its address, ready to roll back.

  4. Observe

    Logs, metrics and traces from its first request.

  • Models

    By usage

  • Compute

    By execution

  • Storage

    By consumption

  • Managed services

    By usage

Intelligence that connectsto every layer.

Agent capabilities sit alongside the inference path; not every request crosses every subsystem.

Semantic + Graph

Retrieve / remember

Semantic retrieval, durable memory, provenance and connected knowledge for agent work.

2.0× multi-hop evidence recall vs cosine

LoCoMo, held-out test split: every evidence turn of a multi-hop question in the top 20 for 37.5% of questions, against 18.8% for cosine search.

One API.Every capability.

The same key, organization, project, policy and usage ledger behind every path. The interface changes; the system does not.

  • api.hanzo.ai/v1/function
  • api.hanzo.ai/v1/provisioning/sql
  • api.hanzo.ai/v1/provisioning/vector
  • api.hanzo.ai/v1/s3/buckets
  • api.hanzo.ai/v1/…

One org, one afternoon: a spaceship shop that did not exist this morning.

Five operations, one key, no glue. Each is checked against the published OpenAPI document on every build.

Start with the models.

GETapi.hanzo.ai/v1/models

Returns the list of available models from the routing table.

Models

Not just running.Learning.

A modular feedback architecture, not a claim of unattended production self-modification. Only candidates that meet the relevant evaluation and release gates are promoted.

Research / recursive improvement

Your cloud shouldnot lock you in.

The platform is open source, and the image we operate is the image you can pull: the same API and console on your cluster, in your network or on a laptop.

$ git clone https://github.com/hanzoai/cloud && cd cloud && make dev
$ curl -sS http://127.0.0.1:9090/healthz

Open

11 native layers

Inspectable product, docs and source links for each architectural surface.

Open source

4 GPU backends

CUDA, ROCm, Vulkan and Metal; backend-specific validation, never blanket speed claims.

Kernel DSL

Measure the work

Published measurements are scoped to a named model, workload, hardware and baseline.

Benchmarks

GPU targets are parallel hardware backends, not sequential stages. Zen is generative reasoning; Kai provides decision intelligence. ZAP is a native RPC protocol for supported interconnect paths. Research and evaluation form a gated improvement loop. “Native” describes Hanzo’s architecture surfaces; not every implementation, weight, driver or operating system is owned or open sourced by Hanzo.

Build on the stack. Or run it yourself.

Models, agents, compute, data, security and observability behind one API, from prototype to production.