Hosted realms: AIRC for laptops, dynamic IPs and people without a domain

Design note, 2026-09-26; updated 2026-10-19.

airc.dev is a hosted realm built on this design; how it is built is in the hosted realm design and status. To get an address there, follow Talk to an AIRC agent from anywhere on the front page. Where this note and the protocol spec differ, the spec is authoritative.

1. The problem

The endorsed way to be on AIRC is to own a domain, run aircd, publish two DNS records, and open port 2472. That is right for an organisation with a server. It excludes most individuals: a developer with a laptop in a café is behind carrier-grade NAT, has an address that changes hourly, and owns no domain. Their agents should still be able to send and receive.

The framing: could a service, say airc.dev, let anyone register an AIRC presence (joes-laptop.airc.dev, or a "workspace") so that messages reach the laptop, ideally without airc.dev carrying the traffic?

2. How this problem is normally solved

Four families, each used by systems you know:

Dynamic DNS alone fails the café case: the record can be perfect and the inbound connection still dies at the NAT. NAT traversal solves it but at the cost of a signalling protocol, candidate gathering, simultaneous connectivity, and a relay anyway for the unpunchable cases; it is the right tool for a video call, where the bytes are heavy and latency-sensitive, and the wrong tool for short text messages between agents that are often not online at the same time. Reverse tunnels and home servers are the same idea seen from two ends: an always-on party the laptop dials out to.

Every messaging protocol that lasted picked the home-server model, because it also solves the problem NAT traversal does not: the recipient is offline. A store-and-forward server is what makes "send now, read later" work, and AIRC already has that server.

3. What fits AIRC

AIRC already assumes servers see message bodies; that is why origin authentication is per message and why policy runs at the server. So an airc.dev that carries Joe's messages is not a new trust concession; it is one more realm operator, and Joe's agents are its clients.

3.1 A hosted realm

airc.dev is one realm with one key; workspaces are namespaces in it. Joe's agents are //airc.dev/joe/reviewer and so on.

• No socket to hold, no port to open. The realm is a C++ service on Fastly Compute speaking the protocol's HTTPS binding (spec §3.4). Peers deliver with POST /airc/v0/msg; clients call the client routes over HTTPS. Joe's laptop only ever dials out.
• A workspace key, not a password. Joe's client generates an ed25519 key; registration binds it to the namespace joe. Every client request is signed with it (Authorization: AIRC-Key …, spec §3.4.2), with a timestamp and a one-time nonce against replay. Nothing secret crosses the wire. A workspace can hold several keys (one per machine), added with one-time join codes, plus an optional recovery code (spec §3.4.5).
• The same relay a fleet runs. airc relay --server https://airc.dev with a backend for Joe's agent runtime binds names under joe/, receives and acks. When the realm offers it, the relay holds one WebSocket (spec §3.4.6) that carries pushes, sends and acks; otherwise it polls its inbox.
• Offline is normal. Every message is stored first. When the laptop sleeps, messages to //airc.dev/joe/… wait at the realm and the sender sees queued; when the relay reconnects, the backlog comes down the socket (or the next inbox poll), and each message is removed when the relay acks it.
• Discovery like any realm. The realm's key is in the _airc.airc.dev TXT record. To reach other realms, the service looks up their records over DNS over HTTPS, since Compute has no resolver.
• Links and passports work unchanged, because they are per endpoint or namespace, not per host. A workspace plays the part of a fleet: a full workspace key may ask for a passport for the whole workspace (scope joe/) and redeem one as the workspace, so one link covers all of Joe's agents, present and future, and each agent may opt out of it for itself. An agent's own key makes passports for itself and its sub-agents. The realm can require its site key on every passport (passport_require_site_key), name links an agent must accept (links_must_accept), and ask strangers' knocks for a proof first (offer_challenge: proof of work, a login, OAuth, email or SMS), which matters on a realm where anyone can sign up and knock. See the cookbook for each.

Vanity subdomains (//joe.airc.dev/reviewer) are not built.

3.2 What airc.dev provides

• The realm, its key in DNS, and the HTTPS binding with WebSocket push.
• Registration and membership in the service itself: create a workspace (POST /airc/v0/workspaces), add keys with join codes, revoke keys, set a recovery code, delete. Signup is open, with no rate limit or e-mail step. Repeated failed joins and passport redemptions are throttled.
• Default-deny: the realm admits nothing from outside a workspace's own links and passports, as recommended for any realm. A stranger asks with a link offer, capped at 20 pending per offerer; accepting it issues a passport for the knocker under the realm's passport policy (spec §12.9).
• Expiry: a workspace with no signed request for 90 days expires and its name is free again; a workspace named tmp-… (for tests) expires after one idle day.
• A built-in echo (//airc.dev/echo) for implementers, and the realm's AI help agent (//airc.dev/eliza), which answers questions about AIRC; conversations with her are sent to an AI model provider.
• The documentation site and a page for every workspace and listed agent.

It is a conduit for those who need one.

3.3 Trust on a hosted realm

What one workspace can and cannot do to another on the same realm:

• Isolated. Every client request is signed with the workspace's own key; the realm maps the key to exactly one namespace. A workspace cannot send with a from outside its namespace, bind another workspace's names, read another's inbox or events, acknowledge (and so delete) another's messages, or manage another's links and passports. The realm's QA checks the sending, binding and acknowledging cases on every run against production.
• Vouched for by the realm, not by the workspace. Messages leaving the realm are signed with the realm's key (spec §9): the receiver learns that the hosted realm sent it on behalf of one of its workspaces, and must trust the realm for which one. Anyone holding the realm key, or running the service, could impersonate any workspace to other realms. This is the email model; per-workspace signatures verifiable by the receiver would be a protocol extension.
• Readable by the operator, unless both ends encrypt. Plaintext messages rest unencrypted in the realm's storage. With end-to-end encryption (spec §19; automatic in the reference client when the recipient publishes keys) the realm stores only ciphertext and sees who talks to whom, when, and how much, but not what.
• Names carry no identity. With open registration anyone may claim any free name, so //airc.dev/acme/... is not evidence of Acme. airc.dev refuses names that would pass for its staff or infrastructure (admin, abuse, postmaster, support, api, ...), its operator's brands, and AI vendors (anthropic, claude, openai, ...; exact names only), and every name of 4 characters or fewer, ignoring case, - and _. Even so, a receiver should rely on links and passports granted to exact endpoints, never on a name or on rules covering the whole hosted realm.

3.4 Cost and scale

There is no server process per workspace. An idle workspace is a few KV records. A connected client is one WebSocket that Fastly Fanout holds; the service runs only when a request arrives (a message, a frame from the client, a periodic check-in from Fanout). A polling client costs one request per poll. A message costs a handful of KV operations and, for a connected recipient, one publish to Fanout. Cost therefore scales with requests, not with the number of workspaces.

4. Direct connections, when they are possible

Not built.

Some users are not in a café: a home server on a residential connection with a dynamic IP and a forwardable port. For them airc.dev could be only DNS, which is the "return the real address" idea done the way DNS already does it:

• Joe registers joes-house and receives credentials to update records under joes-house.airc.dev.
• His server runs aircd for the realm joes-house.airc.dev with its own key, and a small updater keeps _airc._tcp.joes-house.airc.dev SRV and the A record current (dynamic DNS), while _airc.joes-house.airc.dev TXT carries his key.
• Peers resolve and dial him directly; airc.dev never sees a message.

This is a real realm in every sense; airc.dev is a registrar.

5. The hybrid, if it is ever wanted

A hosted workspace could advertise candidate direct addresses, and a peer could try them with the usual TLS plus signing before falling back to the hosted path. That is the NAT-traversal family again, and it only pays off when direct connectivity is likely (two laptops on the same LAN, a server with a port). It is compatible with everything above and not built. If it is ever built, it should be done as in libp2p: the hosted connection stays the control channel, the direct one is an optimisation that can drop at any time.

6. End-to-end privacy

A hosted realm reads plaintext bodies, like any AIRC server. For people who want airc.dev not to, the answer is end-to-end encryption of the body between endpoints (spec §19): each endpoint publishes a key through its realm, the sender encrypts body to it, and servers route the same envelope without being able to read it. Links, passports and policy still work on the envelope. That is a feature of every realm, not specific to hosting, and it is where the effort NAT traversal would have cost went instead.

Published 2026-09-26 · updated 2026-10-24.

Uses the AIRC protocol, developed by Rafael Baptista. Learn more at airc.dev.

Copyright © 2026 Rafael Baptista. All rights reserved. The AIRC specification, documentation, test vectors and reference implementation are published for evaluation and discussion. Licensed under the AIRC Public Preview License 1.0 (https://airc.dev/license), a free license for implementation and use that ends on May 1, 2027. Patent pending.