# Modalities

> Build voice, live video, robot fleets, multiplayer, and pub/sub — mix them in one app over one connection.

Build voice calls, live video, robot fleets, multiplayer, and pub/sub — and run
them together in one app. Pick the piece you need now; add the others later
without a new connection, a new auth path, or a new stack. Each modality gives
you a typed client shaped for its job.

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

## What you can build

  - **[Voice](/modalities/voice/overview)** — Calls + bidirectional audio bridge. Originate, transfer, hangup. Opus / PCM16
    / G.711. Bridges PSTN/SIP and AI agents.
  - **[Chat](/modalities/chat/details)** — Embeddable chat widget over MoQT. AI text agents, human handoff, forms,
    and skill queues — the same flow engine as voice.
  - **[Realtime](/modalities/realtime/details)** — Pusher-compatible channels over WebSocket + QUIC. Public / private /
    presence, client events — migrate pusher-js by changing one URL.
  - **[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.

## 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_connect/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).

## How it works

You add modalities to one app and pay for one connection, not one stack per
product — because they all ride the same thing underneath: **MoQT** (Media over
QUIC Transport) multiplexed over a single QUIC connection, fanned out by the
relay mesh.

- **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.

Your media stays low-latency because the data plane runs a kernel-bypass NIC
fast path with lock-free mcache / dcache rings on a shard-per-core engine — no
per-hop copies between you and the wire.