Diagrams · 44 pages

Every diagram, in one place

I think in pictures, so a lot of Hangar's design lives here. Each diagram is one page with one idea, drawn with the same tool and the same visual style, and each one is clear about what's built and what's still a plan. They're generated from code in the Hangar repo, so this gallery is always up to date.

Every diagram, in one place

Autopilot

Hangar as it is, and the one new component beside it

Durable changes are commits. Ephemeral runs are claims.

The durable path: an agent's write is a git write

Any agent workload is one of six shapes, built from two kinds of thing

From a reviewed definition to a disposable run

What a run gets, and the only two ways out

A run always ends, whether or not anyone is watching

Agent teams: every child is narrower than its parent

Backend infrastructure: three fleet classes, one contract

Two gates out of the sandbox: one for tools, one for models

One call, end to end: identity in, scoped token out, nothing kept

What each kind of agent may do, and who really does it

Effective authority is the minimum of five inputs, and runtime can only lower it

An agent PR goes through the same gates, plus two that are about agents

Flight recorder: reuse the telemetry, add one tamper-evident chain

Preflight: score every agent change against incidents you have already solved

AI triage: move Holmes's GitHub access behind Clearance

Where it runs: dev gets the write path and the runs, upper gets none

Rollout: four phases, each closed by a live check before the next begins

Plan

Hangar with Autopilot: six products and one reference system

Twenty-eight weeks, six milestones, one score to move

What blocks what: the critical path in six boxes

The Airframe scorecard: ten dimensions, measured today

The contract: one source, generated artifacts, four consumers

The parachute sentence, end to end

Skyport gains six AI workloads, one per shape

A delayed flight becomes one draft, and a team, and a human decision

Reference architecture

Agent execution substrate: sandboxed, scoped, disposable

MCP tool gateway: the only road to infrastructure

Golden path as a contract: discover, invoke, verify

CI/CD as a validation loop the agent can retry against

One platform surface across AWS and OCI

Agents are identities: each ring narrows the blast radius

Did the agent do the right thing, and how do we know?

Autonomy is earned per alert class, and revocable

Alerts that resolve themselves, or page with a tested hypothesis

Evaluating infrastructure agents: a regression suite, not a vibe

Glidepath

Glidepath end to end: from a push to a verified release

What you change, and what the platform owns

cicd.yaml, and what actually runs

Getting a new app onto the platform

How test gets started when build finishes

Deploy and release: different questions, different rigor

One dev control plane, and an ArgoCD in every cluster