What does the RecordCue agent CLI output?

JSON metadata for finished recordings: where the media and transcript files are, which service the call was, when it started and ended, capture modes, file size, and a compact run-length-encoded timeline of who was speaking in 100 ms buckets. Three subcommands — latest, list --since, and inspect — all read-only. It analyzes nothing and uploads nothing.

What is RecordCue's speakerActivity format?

recordcue-rle-v1: a string like rc1:100:.20M15S40B5 — the prefix names the format, 100 is the bucket size in milliseconds, and the rest is run-length encoded with four symbols: "." quiet, "M" the microphone was louder, "S" what the Mac played was louder, "B" both. An hour of conversation encodes to a couple of kilobytes, so a script can compute talk-time ratios without touching the audio.

Automate / CLI reference

The agent CLI, in detail

The full JSON, the exit codes, and the one field nobody else ships: a machine-readable record of who was speaking.

The automation hub shows what to build and the hooks recipe shows how to run it when a recording finishes; this page is the reference for anyone — or any agent — writing something of their own. Three subcommands, all read-only: latest, list [--since 7d], inspect <path|latest>, each with --json. The command cannot start, stop or delete a recording, analyzes nothing, and uploads nothing.

The CLI is built into the RecordCue app; it is not a separately installed recordcue command. The Agent Package normally finds it for a compatible local AI agent. The full app command below is for scripts and manual use.

Everything latest prints

$ '/Applications/RecordCue.app/Contents/MacOS/RecordCue' --agent-cli latest --json
{
  "appVersion":       "1.0",
  "capture":          { "kind": "audio", "microphone": true,
                        "systemAudio": true, "video": false },
  "durationMs":       2520000,
  "endedAt":          "2026-07-30T14:44:00Z",
  "id":               "9F2C6A1E-…",
  "media":            { "container": "m4a", "kind": "audio",
                        "path": "/Users/you/Movies/RecordCue/Google Meet/2026-07-30 14.02.m4a",
                        "sizeBytes": 40215552 },
  "schemaVersion":    1,
  "service":          "Google Meet",
  "speakerActivity":  { "data": "rc1:100:.107M1.10M1.1M2.104S38…",
                        "format": "recordcue-rle-v1",
                        "resolutionMs": 100 },
  "startedAt":        "2026-07-30T14:02:00Z",
  "status":           "ready",
  "transcript":       { "path": "/Users/you/Movies/RecordCue/Google Meet/2026-07-30 14.02.txt" },
  "updatedAt":        "2026-07-30T14:45:12Z"
}

The fields a script reaches for: media.path and transcript.path are the files; service names the call; startedAt/endedAt/durationMs place it in time; schemaVersion is what to check before assuming the rest. Two things to code for: transcript is absent, not null, until a transcript exists — in jq that is .transcript.path // empty — and only finished recordings appear at all (status is always ready today; a recording in progress is simply not listed yet).

Exit codes a script can trust

0 — output is the JSON (or text) you asked for.
2 — the arguments were wrong; the message says how.
3 — nothing found: no recordings yet, or the inspected path is not a recording. Watchers should treat this as “try again later,” not as an error.
4 — RecordCue could not complete the recording scan. Do not use a partial result; narrow the search or inspect the recordings folder.
127 — the Agent Skill wrapper could not find a runnable RecordCue app or CLI. This means RecordCue is unavailable, not that there are no recordings.

The speaker-activity timeline

speakerActivity.data is the conversation's shape without its words: rc1:100:.20M15S40B5 reads as “format v1, 100 ms buckets, then two seconds of quiet, 1.5 s where the microphone was louder, four seconds where what the Mac played was louder, half a second of both.” Four symbols: . quiet, M microphone, S system audio, B both. The names are honest on purpose — it knows which signal was louder, not who a voice belonged to. An hour encodes to a couple of kilobytes.

A decoder is a dozen lines of Python:

import re

def decode(activity):
    head, bucket_ms, runs = activity.split(":", 2)
    assert head == "rc1"
    timeline = []
    for symbol, count in re.findall(r"([.MSB])(\d+)", runs):
        timeline += [symbol] * int(count)
    return int(bucket_ms), timeline

def talk_share(activity):
    _, timeline = decode(activity)
    voiced = [t for t in timeline if t != "."]
    if not voiced:
        return None
    mine = sum(t in "MB" for t in voiced)
    return mine / len(voiced)

Which is enough to answer a question no transcript answers well — did I talk too much?

$ '/Applications/RecordCue.app/Contents/MacOS/RecordCue' \
    --agent-cli latest --json | python3 -c '
import json, sys
from talkshare import talk_share   # the decoder above, saved as talkshare.py
r = json.load(sys.stdin)
svc, share = r["service"], talk_share(r["speakerActivity"]["data"])
print(f"{svc}: you spoke {share:.0%} of the voiced time")
'
Google Meet: you spoke 33% of the voiced time

The same timeline can find the monologues (long M runs), the moments everyone talked over each other (B clusters), or the minutes of silence at the start that never needed recording. All from local metadata; the audio itself is never read.

list and inspect

list returns { recordings: […], schemaVersion: 1 }, newest first, and --since takes 7d, 24h or 30m. The week at a glance is one jq away:

$ '/Applications/RecordCue.app/Contents/MacOS/RecordCue' \
    --agent-cli list --since 7d --json | jq -r '
    .recordings[] | [.service, .startedAt, (.durationMs/60000
    | round | tostring) + " min"] | @tsv'
Google Meet   2026-08-14T06:00:00Z   42 min
Zoom          2026-08-13T01:30:00Z   28 min
Slack         2026-08-12T09:05:00Z    9 min

inspect takes one path — from list, from Finder, from anywhere — and returns the same shape as latest. Feed it a folder of old recordings in a loop and an agent can reconstruct a project's whole meeting history, locally.

Why it is shaped this way

The CLI is the second half of the capture-layer bargain: RecordCue does the recording completely and stays out of the thinking. Read-only is not a missing feature — it is what makes the command safe to hand to any script or agent without wondering what else it might do. The User Guide covers setup; the recipes are the fast way in.