AIRE & Vega.
AIRE is an open protocol. Vega is one runtime that happens to speak it. Most people will use AIRE without ever touching Vega.
The short version
- AIRE is an open wire protocol. Apache 2.0. BDFL-governed today, headed for a neutral foundation.
- Vega is an OTP-style agent runtime in Go — supervision trees, restart strategies, fault classification. Think Erlang's BEAM, but for AI agents.
- AIRE is to Vega what POSIX is to Linux — a standard the runtime implements, not a thing the runtime owns.
You can implement AIRE in any language, run it from any process, and interoperate with anyone else who speaks the spec. Vega is one canonical user — not the only one.
The pattern
This is a well-worn pattern. Successful protocols come paired with an opinionated reference implementation that proves the spec is real — and a clear separation between the standard and the runtime.
| Standard | Reference runtime |
|---|---|
| POSIX | Linux |
| OCI | Docker |
| HCL | Terraform |
| AIRE | Vega |
The standard is the durable thing. The reference runtime proves the standard is real.
What lives in AIRE
- Wire format (frame envelope, encoding rules)
- Frame types:
HELLO,CAPABILITY,INVOKE,STREAM,CANCEL,BUDGET,DELEGATE,ERROR,GOODBYE - Handshake and capability negotiation
- Identity model — DID-bound, signed, per-stream
- Cancellation, budget, and resumability semantics
- URI scheme (
aire://)
Nothing in AIRE references Vega. The spec has no normative reliance on any specific implementation.
What Vega adds on top
Vega is an agent runtime. It supervises agent processes (supervision trees, restart strategies, fault classification), provides a YAML DSL for non-programmers, persists state, and integrates with LLM backends. AIRE is the wire on which a Vega cluster's distribution travels — the "how do agents on different hosts talk to each other?" layer.
If you've used Erlang/OTP, the analogy is exact: AIRE is the Erlang Distribution Protocol; Vega is OTP. Independently useful. Exponentially more useful together. Neither owns the other.
The decoupling rules
To keep this honest, the AIRE codebase enforces hard separation:
- No Vega imports in
aire-go. The Go reference implementation has zero dependencies on any agent runtime. Verifiable withgo mod graph. - No Vega in normative spec text. Vega may appear only as a non-normative example, the way Linux might appear in a POSIX comparison.
- Vega is one of N implementations. Anyone can write an AIRE runtime that looks nothing like Vega. The protocol must support that.
What this means for you
| You are… | What AIRE is to you |
|---|---|
| A developer not using Vega | A QUIC-native protocol you can implement against the spec |
| A Vega user | The wire protocol that lets Vega processes on different hosts talk to each other |
| Building an agent framework in Python / TypeScript / Rust | A standard you can ship a client for; aire-go is a reference, not a constraint |
Using AIRE without Vega
You don't need Vega. You need:
- The spec — github.com/aire-protocol/aire-spec
- An implementation — aire-go if you're in Go, or write your own in any language
- A QUIC library in your language (Go:
quic-go; Rust:quinn; Python:aioquic; etc.)
That's it.