kortix-meet

Three things to internalize before you touch a command:

1. It runs through the Kortix Executor. Every meet call goes to the gateway, which resolves the meeting-bot provider's API key server-side and makes the real call. There is no key in your sandbox, nothing to configure, and no $RECALL_*/$MEET_* env var to hunt for. Do not reach for an MCP server, a raw curl, or an HTTP workaround — the meet CLI is the complete, supported interface. If you find yourself looking for an API key, stop: you're on the wrong path.

2. It is bot-id-centric. meet join <url> returns a bot_id. Every subsequent command — status, transcript, leave — takes that bot_id as its argument. The bot_id is the only handle to the meeting. Save it the instant you get it (see "Persisting the bot_id across turns") — without it you cannot check status, fetch the transcript, or remove the bot.

3. A meeting outlives a single turn. Calls run for minutes to hours. You do not sit in a loop blocking your turn for the whole meeting. The work naturally spreads across turns: join now, confirm it's in, then come back later — when the call ends or the user asks — to pull the transcript and write the recap.

Every command prints JSON to stdout. Parse it; don't eyeball it.

meet join ─▶ joining_call ─▶ in_waiting_room ─▶ in_call_not_recording ─▶ in_call_recording ─▶ call_ended ─▶ done
                                  │                                              │
                          (host must admit)                          (capturing audio + captions)

Your job maps onto it:

1. Join (meet join <url>) → capture bot_id, tell the user it's on the way + they may need to admit it.
2. Confirm (meet status <bot_id>) → last code in_call_recording means success. in_waiting_room means it's stuck waiting for the host to let it in.
3. Recap (meet transcript <bot_id>, when the call ends or on request) → turn segments into a TL;DR + decisions + action items.
4. Leave (meet leave <bot_id>) → remove it when done; it bills per minute (it also auto-leaves when everyone else does).

meet join "https://meet.google.com/abc-defg-hij"

Pass the full meeting URL — Google Meet, Zoom, or Teams. The platform is detected from the URL; you don't specify it. Transcription (via the meeting platform's own live captions) is enabled by default, so meet transcript will work later with no extra setup.

By default the bot joins under the name the project set (Customize → Meetings → Bot name; default "Kortix Notetaker") — you don't need to pass it. People also address it by that name in the call (the wake word is its first name).

Options:

• --bot-name "Acme Notetaker" — override the display name for this one call. Keep it honest and recording-disclosing; this is what participants see in the roster, and the first word becomes the wake word.
• --recording-config '<json>' — advanced override of the recording/transcription config (rarely needed; the default already enables captions-based transcription). Example to use a higher-quality async provider instead of live captions: --recording-config '{"transcript":{"provider":{"assembly_ai_streaming":{}}}}'.

Output (abridged):

{
  "ok": true,
  "bot_id": "89532474-1e78-4c4e-b6bb-534d6534b2b2",
  "bot": {
    "id": "89532474-1e78-4c4e-b6bb-534d6534b2b2",
    "meeting_url": { "meeting_id": "abc-defg-hij", "platform": "google_meet" },
    "bot_name": "Kortix Notetaker",
    "status_changes": [],
    "recordings": []
  }
}

→ Save bot_id (89532474-…). Then tell the user the bot is joining and to admit it from the waiting room if prompted.

meet status <bot_id> — where is the bot

meet status "89532474-1e78-4c4e-b6bb-534d6534b2b2"

Returns the bot object, including the ordered status_changes list. Read the LAST entry's code.

Output (abridged):

{
  "ok": true,
  "id": "89532474-1e78-4c4e-b6bb-534d6534b2b2",
  "status_changes": [
    { "code": "joining_call",          "created_at": "2026-06-28T16:00:59Z" },
    { "code": "in_waiting_room",       "created_at": "2026-06-28T16:01:03Z" },
    { "code": "in_call_not_recording", "created_at": "2026-06-28T16:01:09Z" },
    { "code": "in_call_recording",     "created_at": "2026-06-28T16:01:10Z" }
  ],
  "recordings": [ { "id": "…", "status": { "code": "recording" } } ]
}

Last code in_call_recording → it's in and capturing. See "Status codes" below for what each one means and what to do.

meet transcript <bot_id> — speaker-attributed transcript

meet transcript "89532474-1e78-4c4e-b6bb-534d6534b2b2"

Two possible outputs.

Not ready yet (normal early in a call, or before anyone has spoken):

{ "ok": true, "bot_id": "89532474-…", "status": "processing",
  "note": "Transcript not ready yet (still processing or no speech captured). Try again shortly." }

Ready:

{
  "ok": true,
  "bot_id": "89532474-…",
  "segments": [
    { "participant": { "id": 1, "name": "Priya Shah" },
      "words": [ { "text": "Okay" }, { "text": "let's" }, { "text": "ship" }, { "text": "the" }, { "text": "migration" }, { "text": "first." } ] },
    { "participant": { "id": 2, "name": "Marco Diaz" },
      "words": [ { "text": "Agreed," }, { "text": "I'll" }, { "text": "own" }, { "text": "the" }, { "text": "rollback" }, { "text": "plan." } ] }
  ]
}

The transcript is an array of segments; each has a participant (with name — the speaker) and words (an array of { text }). To get a readable line per speaker, join the words of a segment with spaces (see "Reading the transcript").

meet chat <bot_id> "<message>" — talk back in the meeting

meet chat "89532474-1e78-4c4e-b6bb-534d6534b2b2" "On it — sharing the migration doc now."

Posts a message to the meeting chat as the bot, so the agent can participate — answer a question, drop a link, confirm an action. Keep it short; it's a live call. Returns { "ok": true, "bot_id": "…", "sent": "…" }.

meet speak <bot_id> "<message>" — say it out loud (voice)

meet speak "89532474-1e78-4c4e-b6bb-534d6534b2b2" "Sure — Q3 revenue is up twelve percent."

Speaks the message aloud in the call using the project's selected voice (ElevenLabs TTS, generated server-side). Optional --voice <id> overrides the voice for one line. Keep spoken replies short and conversational — plain spoken language, no markdown or URLs (those go in meet chat).

meet leave <bot_id> — remove the bot

meet leave "89532474-1e78-4c4e-b6bb-534d6534b2b2"

Removes the bot from the call. This is irreversible. Do it when the user says they're done, or right after you've pulled the final transcript — it stops the recording from billing per minute.

Full help: meet help.

The posture is listen-by-default. You are not pinged on every sentence (that would be noise). You're woken only when someone addresses the bot by name — i.e. an utterance or chat message that contains the wake word, which is the bot's first name (the project's bot name, "Kortix" by default). A few things the relay handles for you so it feels like a real conversation:

• It waits for the speaker to finish (it coalesces a paused, multi-part sentence into one turn) before waking you — so you get the whole question, not a fragment.
• It plays an instant spoken acknowledgement ("one sec…") the moment you're addressed, so there's no dead air while you think. Don't open your reply with filler — just answer.
• For a short window after a reply, the same person can keep talking to you without repeating your name — stay engaged in the back-and-forth.

When woken, this session receives a prompt like:

[Live meeting] Priya Shah said: "Hey Kortix, can you drop the migration doc in the chat?"

You're attending this meeting live (bot id 89532474-…) and were just addressed.
If a reply is warranted, post it to the meeting chat — keep it brief, you're speaking in a live call:
  meet chat 89532474-… "<your reply>"
If no reply is needed, do nothing.

How to handle a live wake — match the channel they used (the wake prompt tells you which it was):

• They SPOKE to you → you MUST reply out loud with meet speak <bot_id> "…". This is non-negotiable for a spoken turn — never answer a spoken question by typing in the chat, no matter how the answer is shaped (even a few points are spoken aloud as a sentence).
• They TYPED in the meeting chat → reply in the chat with meet chat <bot_id> "…".
• The only time chat enters a spoken turn: the answer contains something genuinely un-speakable — a URL, a code snippet, a file. Then still speak your answer, and additionally meet chat the link/snippet. Speaking is never skipped; chat is only an add-on here.
• Be brief and useful. One or two sentences — you're interjecting in a live conversation, not writing a report. Spoken replies especially must be short, plain spoken language — no markdown, no URLs read aloud.
• It's fine to do nothing. If the mention wasn't really a request to you (someone just said the word "Kortix" in passing), don't reply.
• You can act first, then answer. If they ask for something ("share the Q3 numbers"), do the work, then meet chat the result or a link.

The full end-of-meeting recap still comes from meet transcript <bot_id> — live mode is for in-the-moment interaction, not for capturing the whole call.

When to speak vs. type — the relay tells you which channel they used; match it:

• Someone spoke to you → meet speak (answer aloud). The default for any spoken question.
• Someone typed in the chat → meet chat (answer in the chat).
• A spoken turn is always answered by voice. If part of the answer is genuinely un-speakable (a link, a file, a code snippet), speak the answer anyway and additionally drop the un-speakable bit in chat — e.g. meet speak <id> "Here's the summary — I've put the doc link in the chat." then meet chat <id> "<link>". A list of points is not un-speakable: say it aloud as a sentence.

Write for the ear, not the eye. A spoken reply is heard once, live:

• Short. One or two sentences. Long monologues are painful to sit through on a call.
• Plain spoken language — contractions, natural phrasing. No markdown, asterisks, bullets, headings, or emoji; they get read out as gibberish or dropped.
• Never read out URLs, paths, IDs, or code — nobody can act on a spoken link. Put those in meet chat.
• Say it the way a person would: "twelve percent" not "12%", "the second quarter" not "Q2", "October third" not "10/3". Expand symbols and abbreviations.
• Lead with the answer — no filler. The relay already played an instant acknowledgement before it woke you, so don't open with "Sure, let me check…". Just answer.

Voice: the project default is applied automatically — you don't choose it per call. To deviate for one line, pass --voice <id> (e.g. meet speak <id> --voice george "Welcome, everyone."); the available ids are the voices listed in Customize → Meetings.

Latency: generating + playing speech takes a couple of seconds — that's expected, and the acknowledgement covers the gap. Don't fire a second meet speak because the first seems slow, or the bot will talk over itself.

# they asked out loud: "Kortix, where did we land on the launch date?"
meet speak "89532474-…" "We landed on October third, pending one last design review."

If the bot sits in in_waiting_room and is never admitted, it times out and leaves on its own (no transcript). That's a user action you can't perform — surface it clearly.

A quick way to render the whole transcript readably:

meet transcript "$BOT_ID" | python3 -c "
import sys, json
d = json.load(sys.stdin)
segs = d.get('segments')
if not segs:
    print('(', d.get('note') or 'no transcript', ')'); raise SystemExit
for s in segs:
    who = (s.get('participant') or {}).get('name') or 'Unknown'
    text = ' '.join(w.get('text','') for w in (s.get('words') or [])).strip()
    if text:
        print(f'{who}: {text}')
"

That yields lines like:

Priya Shah: Okay let's ship the migration first.
Marco Diaz: Agreed, I'll own the rollback plan.

Use that readable form to summarize — never dump the raw segments JSON at the user.

# 1) Join — capture the bot_id and stash it where a later turn can read it.
RESULT=$(meet join "https://meet.google.com/abc-defg-hij" --bot-name "Kortix Notetaker")
BOT_ID=$(echo "$RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin)['bot_id'])")
echo "$BOT_ID" > /workspace/.meet-bot-id           # persist across turns

Tell the user: "On it — Kortix Notetaker is joining your standup. If it lands in the waiting room, admit it."

# 2) Confirm it got in (a check or two — not a tight loop).
meet status "$BOT_ID"   # → last code in_waiting_room?  ask them to admit.
meet status "$BOT_ID"   # → last code in_call_recording? it's capturing. Done for now.

…the meeting runs; this turn ends. Later (the user says "summarize it" or the call has ended):

# 3) Recap.
BOT_ID=$(cat /workspace/.meet-bot-id)
meet status "$BOT_ID"        # confirm call_ended / done for a complete transcript
meet transcript "$BOT_ID"    # → segments; render + summarize (see Reading the transcript)

# 4) Clean up.
meet leave "$BOT_ID"         # stop the recording clock (skip if it already auto-left)

Then deliver the recap (TL;DR + decisions + action items) to wherever the request came from.

Losing the bot_id means you can't fetch the transcript or remove the bot — treat it as precious.

• Google Meet — https://meet.google.com/abc-defg-hij
• Zoom — https://zoom.us/j/1234567890?pwd=… (include the pwd if the link has one)
• Microsoft Teams — the full https://teams.microsoft.com/l/meetup-join/… URL

Google Meet is the most battle-tested; Teams and Zoom work but may have platform-specific quirks (waiting-room behavior, recording-consent prompts). If a join fails on a non-Meet platform, report what status says rather than guessing.

• Disclosed, never stealthy. The bot joins as a visible, named participant and everyone in the call can see it. That is by design. Never rename it to impersonate a person, never try to make it hidden or silent, and never describe it to the user as "undetectable."
• Standing to record. Only join meetings the user actually has standing to be in / record — their own calls, ones they host, or ones they're invited to. If you're asked to join a meeting the user doesn't appear to be part of, surface that instead of silently doing it.
• Two-party consent. Many jurisdictions require everyone to know they're being recorded. For calls with external or unknown participants, it's reasonable to note that attendees should be aware a notetaker is recording. When in doubt, err toward disclosure.

When you summarize from a transcript, do not paste the raw transcript. Produce a tight, skimmable recap. Structure:

• TL;DR — 1–2 sentences: what the meeting was about and the outcome.
• Decisions — bullets of what was actually decided, attributed where it matters.
• Action items — a checklist of owner → task (due, if mentioned). Usually the highest-value part; extract it carefully and don't miss owners.
• Open questions — anything left unresolved or needing follow-up.

A good recap looks like:

TL;DR — Sprint planning; team agreed to ship the DB migration before the billing rework.

Decisions

• Migration goes first (Priya); billing v2 slips to next sprint.
• Rollback plan required before the migration merges.

Action items

• Priya → finalize the migration PR — by Thu
• Marco → write the rollback runbook — before merge
• Sam → spike metered-billing schema (timeboxed, 1 day)

Open questions

• Do we need a staging dry-run of the migration first? (unresolved)

Keep speaker attribution where it adds signal, drop it where it's noise. If the transcript is empty or sparse (no one spoke, or captions didn't capture), say so plainly — never invent meeting content to fill a recap.

• connector_not_found / "meet channel isn't enabled" — the meeting bot isn't turned on for this project. Tell the user to enable Meetings in the project's experimental settings; stop (don't improvise another path).
• needs_auth — the provider key isn't configured server-side (an operator setup gap). Report it; you can't fix it from the sandbox.
• A join that lands and immediately fails / bot_failed — bad or expired link, or the platform rejected the bot. Re-check the URL with the user and offer a fresh meet join.
• Transcript keeps saying processing — that's not an error: captions need speech + a little processing lag. Pull it again after the call ends. If it's still empty after the call is done, the call likely had no captured speech — say so.
• Admission never happens — you can't admit the bot yourself; it's the host's click. State clearly that the user (or host) must admit "Kortix Notetaker."