Recording

Recording captures session activity for analysis, compliance, and quality assurance. Zero Runtime Agents support automatic recording with a single configuration flag. Recordings can be accessed in the Zero Runtime Dashboard with transcripts and timestamps, or downloaded for offline review.

How It Works

Enable recording when you serve or invoke the agent, and the framework automatically:

Starts recording when the agent joins the session.
Starts recording for each participant as they join.
Stops and merges the recordings when the session ends.

Audio is always recorded when recording is on. Recording defaults to off, and no pipeline changes are needed once you enable it.

What You Can Record

By default, only audio is captured. Set the additional stream fields on Room to opt in:

Option	Type	Default	Records
`recording_video`	bool	`False`	The agent’s camera video track.
`recording_screen_share`	bool	`False`	The screen-share track. Requires `vision=True` on the same `Room`.

Configure Recording

The quickest way to record every session a process serves is a Room(recording=True) on zeroruntime.serve():

import zeroruntime
from zeroruntime import Room

# Record every session this process serves.
zeroruntime.serve(Assistant, room=Room(recording=True), on_ready=lambda: zeroruntime.invoke(AGENT_ID))

import * as zeroruntime from '@zeroruntime/js-sdk';
import { Room } from '@zeroruntime/js-sdk';

// Record every session this process serves.
zeroruntime.serve(Assistant, { room: Room({ recording: true }), on_ready: () => zeroruntime.invoke(AGENT_ID) });

You can also turn recording on for a single session by setting recording=True on the Room you pass to zeroruntime.invoke():

import zeroruntime
from zeroruntime import Room

zeroruntime.invoke(AGENT_ID, room=Room(recording=True))

import * as zeroruntime from '@zeroruntime/js-sdk';
import { Room } from '@zeroruntime/js-sdk';

zeroruntime.invoke(AGENT_ID, { room: Room({ recording: true }) });

To also record camera video, add recording_video=True to the same Room:

import zeroruntime
from zeroruntime import Room

zeroruntime.serve(
    Assistant,
    room=Room(recording=True, recording_video=True),
    on_ready=lambda: zeroruntime.invoke(AGENT_ID),
)

import * as zeroruntime from '@zeroruntime/js-sdk';
import { Room } from '@zeroruntime/js-sdk';

zeroruntime.serve(Assistant, {
  room: Room({ recording: true, recording_video: true }),
  on_ready: () => zeroruntime.invoke(AGENT_ID),
});

To record the screen-share track, set recording_screen_share=True along with vision=True on the Room:

import zeroruntime
from zeroruntime import Room

zeroruntime.serve(
    Assistant,
    room=Room(
        vision=True,  # required for screen-share recording
        recording=True,
        recording_screen_share=True,
    ),
    on_ready=lambda: zeroruntime.invoke(AGENT_ID, room=Room(vision=True)),
)

import * as zeroruntime from '@zeroruntime/js-sdk';
import { Room } from '@zeroruntime/js-sdk';

zeroruntime.serve(Assistant, {
  room: Room({
    vision: true,  // required for screen-share recording
    recording: true,
    recording_screen_share: true,
  }),
  on_ready: () => zeroruntime.invoke(AGENT_ID, { room: Room({ vision: true }) }),
});

recording_screen_share=True requires vision=True because vision is what subscribes to the video and share streams. Without vision=True, there is no screen-share track to capture, so the screen-share recording has no effect.

Recording Lifecycle Events

Recording lifecycle hooks let you observe when recording starts, stops, or fails without polling any API. They are side-effect-only: they react to events without changing the data flow.

Hooks fire only when recording is enabled. Turn recording on with recording=True on zeroruntime.serve(), or by setting recording=True on the Room you pass to zeroruntime.invoke().

Hook	Fires when
`recording_started`	Recording starts successfully.
`recording_stopped`	Recording stops successfully, typically at session end.
`recording_failed`	Recording fails to start or stop. Use it to surface issues to your monitoring system before the session ends.

@pipeline.on("recording_started")
def on_recording_started(data):
    """Fired when recording starts successfully."""
    print(f"[RECORDING HOOK] Started: {data}")

@pipeline.on("recording_stopped")
def on_recording_stopped(data):
    """Fired when recording stops successfully."""
    print(f"[RECORDING HOOK] Stopped: {data}")

@pipeline.on("recording_failed")
def on_recording_failed(data):
    """Fired when recording fails to start or stop."""
    print(f"[RECORDING HOOK] Failed: {data}")

pipeline.on('recording_started', async (data) => {
  // Fired when recording starts successfully.
  console.log(`[RECORDING HOOK] Started: ${data}`);
});

pipeline.on('recording_stopped', async (data) => {
  // Fired when recording stops successfully.
  console.log(`[RECORDING HOOK] Stopped: ${data}`);
});

pipeline.on('recording_failed', async (data) => {
  // Fired when recording fails to start or stop.
  console.log(`[RECORDING HOOK] Failed: ${data}`);
});

Best Practices

Inform participants that the session is being recorded.
Ensure requests are properly authenticated with a valid token.
Monitor recording status and errors using the recording lifecycle hooks.
Implement a data retention policy and meet the regulations that apply to your users.

Get started

Modalities

Configure Pipeline

Tools and Capabilities

Turn Detection and Interruptions

Telephony Agents

Context Management

Observability and Monitoring

How It Works

What You Can Record

Configure Recording

Recording Lifecycle Events

Best Practices

What’s Next

Analytics

Run Your Agent

​How It Works

​What You Can Record

​Configure Recording

​Recording Lifecycle Events

​Best Practices

​What’s Next

Analytics

Run Your Agent

How It Works

What You Can Record

Configure Recording

Recording Lifecycle Events

Best Practices

What’s Next