A palindrome on purpose: one relay platform that broadcasts and receives, both ways.
Real-time video on Media over QUIC, encrypted end to end.
Sub-60 ms glass-to-glass*, from light hitting one camera to pixels on another screen. MOQOM is a relay, a control plane and native SDKs, built on the IETF's new real-time media standard. Every room is end-to-end encrypted, always, so relays forward media they can't read. You pay what delivery costs, and never more than Agora's list price.
Prepaid credit from $10. No contract and no sales call.
median glass-to-glass latency, 720p30, two iPhone 15 Pros through a cloud relay, both directions at once
- p95
- 70 ms
- Fan-out
- 6,000 viewers
- On
- 4 vCPU
* Built to scale: a Rust media plane and a Go control plane, each scaling out horizontally. Measured in lab: 6,000 viewers on one 4-vCPU relay, every frame delivered. Full data at moqom.cloud/benchmarks/load-tests.md.
Fast enough to talk. Locked down enough to trust.
Nothing is unhackable, and anyone who says so is selling something. What we can do is make every credential short-lived, scoped and tied to a device, and keep media encrypted the whole way.
- Speed
56–57 ms, camera to screen.*
- Median glass-to-glass at 720p30, 1.25 Mbit/s, two iPhone 15 Pros through a cloud relay, both directions at once. p95 70 ms.
- 6,000 viewers on one 4-vCPU relay with zero loss.* The last viewer gets the same stream as the first.
- QUIC streams, so one lost packet doesn't stall everything behind it.
- Security
Encrypted on every hop, and end to end in every room.
- TLS 1.3 on every connection. QUIC doesn't offer a plaintext mode, so neither do we.
- Per-frame end-to-end encryption (SFrame, RFC 9605, AES-256-GCM) is required in every room, with keys agreed using post-quantum ML-KEM-1024 and ML-DSA-87. Nobody can turn it off, us included. The relay forwards ciphertext it can't read or reorder.
- Relays can't mint tokens, and they talk to the control plane over mutual TLS. Bans close live sessions, not just the next join.
- Keys
Built to stop man-in-the-middle and injection attacks.
- Every hop is TLS 1.3 with certificate checks, so nobody on the network can read or alter traffic in transit, and there's no plaintext mode to downgrade to.
- An intercepted token is useless: each one is bound to the device it was issued to, in the Secure Enclave on Apple devices, lasts 15 minutes at most and is signed with post-quantum ML-DSA-87.
- Every frame is authenticated on the device, so a forged, altered or replayed frame is rejected, even one sent by a relay.
- API keys are shown once, stored only as hashes, compared in constant time and revocable instantly.
Why MOQOM
- 01
One stream for calls and broadcast
The stream that carries a two-person call also reaches an audience of thousands. One protocol and one SDK, with no second product to move to when the audience grows.
- 02
Sub-60 ms glass to glass*
56–57 ms median from light hitting one camera to pixels on another screen: two iPhone 15 Pros through a cloud relay, both directions at once.
- 03
Encrypted per frame
Every frame is encrypted on the device before it leaves, with keys that never leave your users' devices, so not even MOQOM can see it. A 1080p keyframe takes about 54 µs* to encrypt, a sliver of a 33 ms frame budget, with no perceptible delay.
* Built to scale: a Rust media plane and a Go control plane, each scaling out horizontally. Measured in lab: 6,000 viewers on one 4-vCPU relay, every frame delivered. Full data at moqom.cloud/benchmarks/load-tests.md.
Fast for the people on the call. Efficient for the people paying for it.
Glass-to-glass counts everything a person experiences: capture, encode, network, buffer, decode and display. Fan-out is one relay and one track, and a size only counts if every viewer got every frame.
Measured in lab: 6,000 viewers on one 4-vCPU relay, every frame deliveredIn the open
Developer signups
Early access. This is the real count, refreshed every minute.
56–57 ms median and 70 ms p95: two iPhone 15 Pros on ordinary home Wi-Fi in Venice Beach, California (about 108 Mbps down, 8 Mbps up), shared with TVs and other devices streaming movies at the same time; GCP relay in us-west2. Fan-out: GCP n2-standard-4, one publisher, one track, 6,000 is the largest size tested, not the ceiling. Not production SLAs. Full results →
* Built to scale: a Rust media plane and a Go control plane, each scaling out horizontally. Measured in lab: 6,000 viewers on one 4-vCPU relay, every frame delivered. Full data at moqom.cloud/benchmarks/load-tests.md.
Built for the network your users actually have.
Mobile video and data run on networks that drop, switch and congest. MOQOM treats that as the normal case: the network and the SDKs heal themselves, and it’s on by default.
Survives the network switch
Walk out of Wi-Fi onto cellular and the QUIC connection moves with you. No redial, no new handshake, no dropped call.
Heals itself
If the network does drop, the SDK reconnects with backoff and restores subscriptions, mutes, grants and stage position exactly. Others see you as reconnecting, not gone.
Bends instead of breaking
Bandwidth is estimated continuously and video steps down a layer before it stalls. Buffers drop late frames rather than freezing the picture.
No head-of-line stalls
Every track rides its own QUIC stream, so a lost packet on one never holds up the others. Missed pieces are fetched back or skipped, never waited on forever.
The picture comes back. Fast.
Every relay keeps the most recent seconds of every stream, about 16 seconds by default. Viewers who join late, drop out or want to see it again are served from the nearest relay, not from the person publishing.
First frame, instantly
A new viewer gets the group already in progress, so a tile fills the moment it opens instead of sitting black until the next keyframe.
Back on screen after a drop
After a drop, the SDK reconnects, rebinds every subscription and fills the picture from the relay’s recent history. No relayout, no blank screen.
Instant replay
Replay the last seconds of anyone’s video as its own stream, without disturbing the live picture. How far back depends on what the relay holds.
Never slows the live edge
History is kept alongside live forwarding, never in its path, so it can’t stall the stream. It works with end-to-end encryption: relays keep ciphertext they can’t read.
Durable event streams, too. Every join, mute, grant change and moderation decision is stored before it is sent, numbered in order per room. A backend that restarts picks up from its last event and gets everything it missed, so no moderation verdict falls through the gap.Events guide →
Encrypted on the device. Not even MOQOM can see it.
In every room: every frame of audio, video and data is sealed on the sender’s device withSFrame (RFC 9605) using AES-256-GCM with SHA-512, and opened only on the receiver’s. The devices agree those keys with post-quantum cryptography, so a call recorded today stays sealed even against a future quantum computer, and every signature that says who someone is is post-quantum too, so nobody can impersonate them with one either. Relays, MOQOM and the cloud underneath carry ciphertext they cannot read. It runs on the phone’s hardware AES, about 54 µs per 1080p keyframe. There is no setting that turns it off.
Post-quantum authentication, not just secrecy
Some messengers made recorded messages quantum-safe but kept classical identity keys, so a future quantum computer could still impersonate a contact. Here every identity key, device credential, key package, group change and message signature is ML-DSA-87, so impersonation is quantum-resistant too.
Post-quantum, end to end
Room keys are agreed with ML-KEM-1024 and every member’s handshake is signed with ML-DSA-87, NIST’s post-quantum standards (FIPS 203 and 204), inside MLS (RFC 9420). Media stays on AES-256, which a quantum computer doesn’t break, so it costs no more than before. There is nothing to turn on.
Standard cryptography, nothing homemade
SFrame and MLS are IETF standards, ML-KEM and ML-DSA are NIST’s, and AES-256-GCM is the cipher banks and governments use. Every primitive comes from Apple’s CryptoKit, not our own implementation, and where we combine them the result is checked against Go’s standard library with shared test vectors.
More than AES-GCM alone
AES-GCM protects the bytes it encrypts. MOQOM also binds each frame’s position, priority and timing into the seal, so a relay can route frames but can’t reorder, relabel or swap them without the receiver noticing.
Replays refused
Every frame’s key and counter are accepted once. A captured frame sent again, or an old one sent late, is rejected instead of played.
Nonces never repeat
A repeated nonce is the one way AES-GCM fails badly. Each sender’s nonces come from its own counter, so they never repeat.
Can’t be skipped
Encryption wraps the stream writer itself, so there is no path from a frame to the network that goes around it.
Two layers, not one
Under SFrame, every hop also runs TLS 1.3 inside QUIC, with ML-KEM-1024 key exchange on every device connection and every link between our servers. The SDK brings its own QUIC and TLS stack, so the phone’s operating system doesn’t get to pick something weaker. Classical-only key exchange is refused, and only devices holding a valid, device-bound token can join. Breaking one layer still leaves the other.
Keys are agreed on the devices with MLS (RFC 9420) using MLS_256_MLKEM1024_AES256GCM_SHA512_MLDSA87, the category-5 suite from the IETF’s post-quantum MLS cipher suites draft. Join tokens are signed with ML-DSA-87 and last 15 minutes at most, and the phone proves it holds its token with ML-DSA-87 too. The libraries that do all of this are open source.Post-quantum authentication, compared with Signal →What is and isn’t post-quantum →
One publisher, one relay hop, thousands of viewers.
MoQ moves media as named tracks over QUIC, so a relay forwards it without decoding it. Your backend controls who joins. The relay handles the rest.
- 1
Your backend mints a token
With the Go or Rust SDK, create a room, set its policy and mint a short-lived token naming the tenant, the room and exactly what this participant may do.
- 2
The app joins over QUIC
The client SDK connects to the relay over QUIC or WebTransport. Both use one UDP port, so the handshake is the only setup. Media starts on a keyframe.
- 3
The relay fans out
Each track is pulled from the publisher once, however large the audience. When the last viewer leaves, the relay stops pulling it.
Connect, join, and you're in the room.
MoqomKit is an open-source (Apache 2.0) SDK that both streams and plays. It is pure Swift, with its own implementation of the IETF MoQ transport draft-19 rather than a wrapper around a Rust core, and no third-party dependencies. It uses async/await throughout and is Swift 6 strict-concurrency clean.
- Hardware encode and decode through VideoToolbox, HEVC and H.264
- Tiles are fetched at the size they're shown, and a track nobody is watching stops being sent at all
- Muting stops bytes at the encoder instead of sending silence, and the relay forwards without ever decoding
- The SDK renews the token before it expires, without reconnecting
- No handoff. A viewer becomes a guest or host on the same connection: the token's grants change, nothing reconnects
- Reconnects after a network change and restores the room's exact state
- Raw frames and samples are available after decryption, for your own processing
- Zero-copy on Apple platforms: frames stay in GPU memory from camera to hardware encoder, and from decoder to screen
- Go and Rust SDKs for the server side, over gRPC, with user management and a live stream of room events built in
- Analytics stay anonymous: usage is metered by role, tier, seconds and bytes, not by person
- No advertising IDs or ad keys in the SDK. Your app can add its own if it chooses
import MoqomKit
let deviceKey = try DeviceKey.installed() // lives in the Secure Enclave
// Your backend (moqom-go or moqom-rust) mints a short-lived token
// and tells the app which relay to use.
let (issued, relay) = try await backend.join(room: "standup", device: deviceKey)
let session = MoqomSession(
transport: MoqtTransport.network(),
credentials: DeviceCredentials(
identity: ParticipantIdentity(username: try Username("ada"),
device: try DeviceID("ada-iphone")),
token: issued.token,
deviceKey: deviceKey,
expiresAt: issued.expiresAt,
renew: { try await backend.join(room: "standup", device: deviceKey).0 }
),
tenant: TenantID("acme")
)
try await session.connect(to: relay)
let room = try await session.join(room: RoomID("standup"))
for await state in session.states {
print("session:", state) // connecting, connected, reconnecting…
}Native on Apple platforms today. Everywhere else is next.
End-to-end encrypted in every room. Required, not an add-on.
TLS 1.3 protects every media connection, because QUIC requires it, and end-to-end encryption protects the media inside it. MOQOM adds protections on top of that, and they come built in rather than left for your application to write.
Encrypted media payloads
Every track is SFrame-encrypted on the device (RFC 9605, AES-256-GCM). The keys never leave your users' devices, so not even MOQOM can see the media; relays forward ciphertext and still cache and prioritise it. No perceptible latency: about 54 µs per 1080p keyframe. (Secure Frame, the IETF standard, not the Simple Frame stack-trace format.)
Tokens bound to the device
Every token is bound to an ML-DSA-87 key held in the device's Secure Enclave, and relays refuse a session that can't prove it holds that key. A token copied off the phone is useless anywhere else. Stricter than DPoP: binding is mandatory, the key is in hardware, and each proof is post-quantum, used once and tied to the connection it's sent on.
Bans take effect mid-session
Kick or ban someone through the admin API and their open connection closes. You don't have to wait for their token to expire.
Tenant isolation by construction
Every token names a tenant, a room and a set of grants, and the relay checks them against every namespace a request touches.
AI agents in the room. Only the ones you choose.
MOQOM is AI native: agents join a room over the same protocol and relays as people, with their own scoped keys, so there is no separate AI path to bolt on. Attach them to live video for detection, classification, moderation, safety, captions, analytics or compliance, picked room by room. They work in real time, and they never watch in secret.
Pick what runs
Safety, classification, analytics, compliance, recording, or an agent of your own. Choose per room from your backend, cap how many attach, or rule out recording entirely.
Agents can moderate
An agent moderates with only the permissions you grant it. Every action lands in the room's audit log, and when a model made the call, the log names the model. MOQOM's own safety agents flag and limit in real time, and a person decides every kick and ban.
Private by design
Run detection and captions on the device, on decoded frames, so the media never has to leave the phone to be analysed. With end-to-end encryption, servers only ever see ciphertext.
Record at no extra cost
Room agents run privately inside your tenant and can record or capture data from a room. There is no recording fee: an agent is billed like any other viewer, at the same rate, and storage is passed through at cost. Self-hosted, you pay your own cloud bill plus the per-GiB platform fee.
AI participants with personalities
In progress. An agent can join as a participant: an animated, talking avatar with a personality you choose, running on on-device AI, that reacts to chat, captions and stream events like games. It can be put on stage, muted or removed like anyone else.
Disclosed, never hidden
Agents never pose as people or pad the viewer count. Each one is announced to the room and AI participants are always labelled as AI, so your app can show who is listening, recording, analysing or talking.
Play together, live, on the same stream.
Game state rides the same connection as the video, so host and viewers share one moment rather than two that drift apart.
AR games, shared live
A host plays an AR game in their room while cohosts and viewers see the same board in theirs, in step with the video.
Every move in order
Game events are numbered and arrive in order, never duplicated, never reordered. A slow network can delay a move, but it can’t change the result, and a viewer who reconnects lands in the exact current state.
Smooth at 60 ticks a second
Positions and rotations travel as flat binary data that the renderer reads in place, zero-copy: a 50-entity tick reads in about 6 µs, so parsing never costs a frame and playback stays smooth.
Data channels built for speed, and for the worst sender in the room.
Data rides with the video
Chat, game state, reactions, telemetry: any app data travels as tracks on the same QUIC connection as the media, prioritised and fanned out by the same relay.
Zero-copy decode
A FlatBuffers-style layout the client reads straight out of the received buffer, with no parse step and no allocation, and positions go to the GPU as they arrived. A 50-entity game tick reads in 5.7 µs against 163 µs for JSON and is 1.9× smaller, without FlatBuffers’ 7,400-line runtime.†
Encrypted like media
TLS 1.3 on every hop, always. Data is end-to-end encrypted on the device too, and the relay forwards ciphertext it can’t read. Sealing a 60-byte message takes about 3 µs.†
Hostile input assumed
Every read is bounds-checked and a malformed record returns an error instead of crashing. Tested against truncation at every length and thousands of random buffers.
† Measured in a release build on an Apple M1 Pro MacBook Pro, averaged over 200 runs: reading every moved position out of one tick of 50 entities (1,831 bytes; 3,528 as JSON), and sealing one 60-byte object with SFrame.Every data benchmark →
15% under Agora. At every tier, at every volume.
Real scenarios, per hour, against Agora’s list price.
15% savings
4K viewer
One viewer watching 4K for an hour
- Agora
- $1.08
- MOQOM
- $0.92
15% savings
Co-host at 540p
A co-host seeing two others in 540p tiles, one hour
- Agora
- $0.54
- MOQOM
- $0.46
15% savings
9-person grid at 180p
Nine people in a 3×3 grid, each seeing eight 180p tiles, per person-hour
- Agora
- $0.24
- MOQOM
- $0.20
A third of a phone screen is about 180p wide, so smaller tiles stay in the HD tier and lose little you can see.
24% under Agora’s list
At volume
An HD host past 1,000,000 participant-minutes in a month, per hour
- Agora
- $0.24
- MOQOM
- $0.18
Agora’s own volume discount brings its price to $0.22. MOQOM applies the same discount and stays 15% under it, with no contract.
69% savings self-hosted
Self-hosted relays
1,000 viewers at 720p for an hour, relays on your own servers
- Agora
- $119.40
- MOQOM
- $37.72
You run the relays and pay your own cloud costs. MOQOM meters bandwidth only, at $0.05/GiB, and never charges more than the same minutes would cost hosted. Agora’s cheapest rate works out to about $0.16/GiB (720p–1080p to a broadcast audience), so the fee is about 69% under it, about 90% under at 360p and 97% for audio. No extra fee for recording or other features.
Per participant-hour at first-band rates unless noted, launch pricing, subject to change before general availability. Agora: Interactive Live Streaming list prices and automatic volume discounts, October 2026. Tiers follow Agora’s: the total pixels a participant receives at once. Actual charges are metered by the second.
Every rate is 85% of Agora's Interactive Live Streaming list price, after the same automatic volume discount Agora gives, and always at least 1¢ under it per 1,000 minutes.
Ship end-to-end encrypted real-time video this week.
Create an account, get an API key, add credit and join your first room.