# Modalities

> Nine typed modalities over one QUIC + MoQT substrate. Pick what you're building; mix them in one app.

ClutchCall is **modality-oriented**. The same QUIC connection and MoQT relay
mesh underneath serves every modality, each with the wire model that fits its
workload. You pick exactly what you're building — and mix modalities in one app
freely, because they share the same connection, auth, and relay.

```ts
import { Voice }    from "@clutchcall/sdk/voice";
import { Streams }  from "@clutchcall/sdk/streams";
import { Robotics } from "@clutchcall/sdk/robotics";
import { Games }    from "@clutchcall/sdk/games";
import { Data }     from "@clutchcall/sdk/data";
```

## The nine modalities

  - **[Voice](/modalities/voice/details)** — Calls + bidirectional audio bridge. Originate, transfer, hangup. Opus / PCM16
    / G.711. Bridges PSTN/SIP and AI agents.
  - **[Streams](/modalities/streams/details)** — Live one-to-many broadcast + VOD. RTMP / SRT / WHIP / TUS2 ingest, CMAF
    packaging, signed playback over WebTransport.
  - **[Robotics](/modalities/robotics/details)** — Topic pub/sub for robot fleets. ROS 2 (CDR), Zenoh-over-QUIC, and MQTT onto
    one mesh. Telemetry / command convention baked in.
  - **[Games](/modalities/games/details)** — Multiplayer rooms with state (server→all), input (player→server), event
    (any→any) channels.
  - **[Data](/modalities/data/details)** — MQTT-style typed pub/sub. Topic filters with `+` / `#`. Retained messages.
    No broker — the relay is the fan-out.
  - **[Netcode (Unity)](/modalities/netcode/details)** — Drop-in transport for Netcode for GameObjects / Entities. Same wire model as
    Games, behind the Unity Transport API.
  - **[Crypto](/modalities/crypto/details)** — Block-dissemination network: low-latency Solana feeds in, native TPU
    transaction delivery out. QUIC-only.
  - **[Tunnel](/modalities/tunnel/details)** — Expose a local TCP/HTTP service through a QUIC data plane. Remote desktop
    rides the same raw-QUIC transport.
  - **[Inference](/modalities/inference/details)** — Duplex audio into one speech-to-speech model over a single QUIC connection.
    Turn detection built in.

## The substrate

Under every modality sits the same thing: **MoQT** (Media over QUIC Transport)
multiplexed over a single QUIC connection, fanned out by the relay mesh. The
data plane runs an AF_XDP kernel-bypass fast path with lock-free mcache / dcache
rings on a shard-per-core engine, so adding modalities to one app costs one
connection, not one stack per product.

What this means in practice:

- **One auth path.** A single tenant token authorizes every modality you use.
- **One connection.** Voice + games + data side-by-side in one process share
  the same QUIC link — no per-modality handshake tax.
- **One relay mesh.** Browsers, native SDKs, and Unity clients all reach the
  same edge POPs.
- **One scaling story.** When the relay scales, every modality scales with it.

## Each modality, four pages

Every modality is documented the same way:

| Page | What's in it |
| ---- | ------------ |
| **Details** | The wire model, lanes/QoS, codecs, when to use it, and the data-flow diagram. |
| **SDK Methods** | The typed SDK surface — imports, classes, every public method and event. |
| **Cookbook** | Short, copy-pasteable "how do I X" recipes. |
| **Recipes** | Longer end-to-end worked examples that combine several methods. |

## When to drop below a modality

The modalities cover the common shapes. When you have a non-shape — a custom
protocol, a research experiment, a transport another codebase already uses —
import `@clutchcall/sdk/moqt` and work with `MoqtClient` directly. You get
`publishFrame` / `publishAudio` / `publishVideo` / `subscribe*` and the same
auto-reconnect, capability routing, and relay fan-out the modalities use. See
[Realtime Tracks](/concepts/realtime-tracks).