> ## Documentation Index
> Fetch the complete documentation index at: https://docs.genesiscomputing.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Meeting Tools

> Join live Zoom, Google Meet, and Microsoft Teams calls, and manage the agent's meeting session.

## `meeting_tools`

These tools let an agent join a live Zoom, Google Meet, or Microsoft Teams call
through Recall.ai, read its transcript, post in its chat, check the bot's status,
and leave. What is said and typed in the call arrives in the conversation's meeting thread,
associated with the person who invited the agent. By default that is the
current conversation; `new_thread=true` creates a separate thread. The meeting
tools work from either the meeting thread or the conversation that asked the
agent to join; use `new_thread=true` when its contents should not reach that
conversation.

The live voice is the same meeting agent and follows its meeting chat. It can
post links and other text directly in that chat; its meeting-specific reads and
guarded handoff of other requests are described in \[Showing Things in a Meeting]
(/docs/User-Guide/Meeting-Canvas).

For Recall.ai-backed meetings, an administrator must configure a Recall.ai
Meeting Bots connection. The Genesis event endpoint must be reachable at a
public HTTPS address. See [Recall.ai
connections](https://docs.genesiscomputing.com/docs/Setup/Connections.md#recallai-connections) and the
[Recall.ai event endpoint](https://docs.genesiscomputing.com/docs/Genesis-API/API-Reference.md#recall-ai-event-endpoint).
Enable the `meeting_tools` group for the agent.

### Actions

| Tool | Purpose |
| - | - |
| `join_meeting` | Join a supported live meeting and return the thread that holds it as `meeting_thread_id`. |
| `send_meeting_chat` | Send a message to everyone in the meeting chat. |
| `send_meeting_recap` | Send the invited person a recap by Slack direct message when authorized and linked. |
| `react_in_meeting` | Post one of the meeting platform's supported emoji reactions in the meeting chat. |
| `raise_hand` | Ask for the floor by raising a hand and naming the point. |
| `lower_hand` | Lower the agent's raised hand, optionally posting the point in meeting chat. |
| `mute_myself_in_meeting` | Mute or unmute the agent's live voice, or turn it fully off. |
| `set_meeting_language` | Change the live voice's spoken language and/or the meeting transcript language without leaving the call. |
| `get_meeting_status` | Read Genesis's status and the latest status Recall.ai reports. |
| `get_meeting_participants` | List people currently in the call and those who have left. |
| `get_meeting_transcript` | Read recent spoken and typed meeting lines from the meeting thread. |
| `look_at_meeting_screen` | Inspect the latest screen-share frame in a meeting and answer a question about it. |
| `canvas_show`, `canvas_update`, `canvas_remove`, `canvas_clear` | Show, change, remove, or clear elements on the meeting canvas. |
| `canvas_mark`, `canvas_restyle`, `canvas_status`, `stop_sharing` | Mark or restyle the canvas, inspect it, or stop sharing. |
| `canvas_browse`, `canvas_preview`, `canvas_query` | Browse the inviter's data, preview a table, or run a quick read-only query. |
| `tell_meeting_voice` | Give the live voice a task answer to say, or advice to consider. |
| `note_meeting_work` | Tell the live voice what work is in progress or what state a task reached. |
| `leave_meeting` | Take the agent's bot out of the call, or leave and rejoin the same meeting. |
| `follow_meeting` | Choose whether to receive updates on a timer or only when someone names the agent. |
| `meeting_director_code` | Give the inviter or an approved participant a one-time code to identify themselves in meeting chat. |
| `record_meeting_consent` | Record a signed-in participant's own yes to let other people ask read-only questions about their Genesis data for the rest of the meeting. |
| `forget_meeting_accounts` | Forget the signed-in person's remembered Zoom or Teams identities. |

### Meeting canvas tools

The canvas is shared with everyone in the call. These tools work from the meeting thread; the
live voice can also use them directly. When a person's live Talk session hands a chat work
for its canvas, the text-side canvas calls from that chat operate on the person's Talk pane,
visible only to them and without a meeting permission step. This includes `canvas_query`;
when there is no active meeting or Talk canvas, `canvas_query` still runs the read as the
signed-in person and returns its rows, but does not show them on screen. Otherwise, the meeting
canvas rules apply: the first show asks for permission, and reads run as the person who invited
the agent using that person's connection access. For the screen-sharing behavior, see
[Showing Things in a Meeting](https://docs.genesiscomputing.com/docs/User-Guide/Meeting-Canvas.md).

#### Show and fetch content

| Tool | Parameters | Purpose |
| - | - | - |
| `canvas_show` | `kind` (required string: `chart`, `grid`, `mermaid`, `card`, `text`, `html`, `image`); `title` (string, `""`); `name` (string or null, null); kind-specific content fields below; `position` (string or null, `auto`); `box` (JSON string or null, null); `add` (boolean, `false`); `replace` (boolean, `false`); `task_id` (string or null, null) | Show one real result or authored element; by default it replaces the canvas, while `add=true` places it beside existing content. A richer element is not replaced by a poorer one unless `replace=true`. |
| `canvas_browse` | `connection_id`, `database`, `schema` (optional strings, omitted); `show` (boolean, `true`) | List usable connections, databases, schemas, or tables. |
| `canvas_preview` | `connection_id` (string, required); `table` (string, required); `database`, `schema` (optional strings, omitted) | Query and show up to 25 rows from a table. |
| `canvas_query` | `sql`, `connection_id` (strings, required); `title` (string, `""`); `show` (string: `grid`, `chart`, or `none`, `grid`); `x`, `y` (optional strings, omitted); `chart_type` (string or null, defaults to `bar`); `name` (string or null, null); `add` (boolean, `false`); `position` (string or null, `auto`) | Run a single read-only query, returning at most 200 rows after at most 30 seconds; show the result as a grid or chart unless `show="none"`. |

`canvas_browse`, `canvas_preview`, and `canvas_query` share a 30-second quick-read limit.
See [the live canvas guide](https://docs.genesiscomputing.com/docs/User-Guide/Meeting-Canvas.md) for timeout, cancellation, and
concurrency behavior.

For `canvas_show`, chart content is `query_id` with `x` and `y`, or a Plotly `spec`; grid
content is `query_id` or `columns` and `rows`; diagrams use `source`, cards use Markdown
`body`, text uses `text` with optional `size` (`s`, `m`, `l`, `xl`; `m`), `align` (`left`,
`center`, `right`; `left`) and `tone` (`plain`, `accent`, `muted`, `callout`; `plain`), HTML
uses `html`, and images use `file` (`scratch/<path>` or `uploads/<path>`). A chart's
`chart_type` is `bar`, `line`, `area`, `scatter`, or `pie`. `position` accepts `auto`,
`full`, `left`, `right`, `top`, `bottom`, the corners, or `center`; `box` is
`[x, y, width, height]` on the 1920-by-1080 canvas. Example:

```python theme={null}
canvas_query(
    sql="SELECT year, COUNT(*) AS games FROM f1.races GROUP BY year",
    connection_id="databricks.prod",
    title="Races per year",
    show="chart",
    x="year",
    y="games",
)
```

`canvas_query` accepts one read-only query, stores its result with the meeting thread when
there is one, and returns the query id and first rows for the agent to discuss. In a chat with
no active canvas it returns the rows without displaying them. `canvas_browse(show=false)`
returns the listing without putting it on screen. A query or preview skeleton appears as soon
as the call is allowed to share; its data fills that same canvas element when the read ends.

#### Change and inspect the canvas

| Tool | Parameters | Purpose |
| - | - | - |
| `canvas_update` | `name` (string, required); `title`, `body`, `text`, `html`, `source`, `position` (optional strings, omitted); `box` (JSON string, omitted) | Change an element's title, content, position, or size in place. |
| `canvas_remove` | `name` (string, required) | Remove one element and its marks; removing the last element leaves the share active and empty. |
| `canvas_clear` | Context-injected `bot_id` and `thread_id` | Remove every element and mark while keeping the share active. Refused when the canvas is already empty. |
| `canvas_mark` | `op` (required string: `point`, `box`, `circle`, `arrow`, `stroke`, `note`, `undo`, `clear`); `target`, `part`, `text`, `points` (optional strings, omitted) | Draw or undo a mark; `points` is a JSON list of pixel coordinate pairs. |
| `canvas_restyle` | `name` (string, required); `highlight`, `filter`, `zoom_from`, `zoom_to`, `sort` (optional strings, omitted); `desc` (boolean, `false`); `page` (string or null, null) | Change chart highlights, filters, zoom, or grid sorting and paging in place. For grids, `page` accepts `next`, `previous`, `first`, `last`, or a page number (1 is the first). |
| `canvas_status` | Context-injected `bot_id` and `thread_id` | Read the elements and marks sent to the screen, whether the screen confirmed drawing the latest change, sharing permission state, and recent query results. |
| `stop_sharing` | Context-injected `bot_id` and `thread_id` | Stop sharing and clear the canvas; permission is requested again before the next share. |

Canvas-changing calls distinguish a change sent to the stage from one the page confirmed it
drew. Say that a change is on screen only when the response confirms it; otherwise say it was
sent but is not yet confirmed. These changes wait up to one second for the page's draw report.

```python theme={null}
canvas_mark(op="circle", target="games", part="1904")
canvas_restyle(name="games", highlight="1904")
```

### `join_meeting`

| Parameter | Type | Default | Description |
| - | - | - | - |
| `meeting_url` | string | required | Zoom, Google Meet, or Microsoft Teams meeting link. A link typed without `https://` (or with `http://`) is accepted and normalized to HTTPS. |
| `connection` | string or null | `null` | Recall.ai connection to use. If omitted, Genesis resolves the usable default or uses the only unambiguous available connection; Genesis AI is used when no Recall.ai connection is configured. |
| `introduce` | boolean | `true` | Post a one-line introduction in meeting chat after admission. Set `false` to join quietly. |
| `new_thread` | boolean | `false` | Put the meeting in its own thread instead of the current conversation. Use this when meeting content should not reach everyone in the current conversation. |
| `transcript_language` | string or null | `null` | Language code such as `ru`, `de`, or `ja`, or `auto` for detection. Omit for English. Non-English transcript updates can arrive 3–10 minutes late. |
| `bot_id`, `thread_id`, `user_id`, `user_email`, `input_metadata` | implicit | current context | Supplied by Genesis for the agent, conversation, person, and request provenance. |

The bot joins using the first word of the agent's name followed by `Genesis`
(for example, `Gennie Genesis`). When the install's Action Review
rules require approval, the join waits for a person; the agent has not joined
while the request is pending. Approving the held request usually sends the bot
into the meeting immediately; the originating conversation is told the outcome.
Only one active meeting can be held in a conversation. If it already has one,
leave it first or pass `new_thread=true` to hold another meeting in its own
thread. Do not call `join_meeting` again while approval is pending, because that creates
another request. After a successful request, the returned
`meeting_thread_id` identifies where meeting speech and chat arrive. The host
may still need to admit the bot. With `new_thread=true`, the meeting's own
thread appears in the thread list as soon as it starts, and the result includes
`meeting_thread_link` to open it.
When the install has a public address and `introduce=true`, the post-join
greeting in meeting chat includes one shared Genesis link for the meeting.
Anyone who signs in and is allowed to use the agent can use that link to get
their own one-time code: the inviter gets director authority, while another
participant is bound as a participant and may act only within their own access.
Until that participant's turns run under their own identity, the agent answers
them in meeting chat only.
The link does not offer sign-up. Set `introduce=false` to join quietly without
that greeting. Unconfirmed reads are available only while a verified person is
in the call.
Genesis notifies the conversation that requested the join when it detects that
the call has ended.

After joining, the agent states its default rather than asking what to do: it
takes notes, stays silent unless addressed, and posts an end-of-meeting recap in
this conversation when `meetings.recap_at_end` is enabled. The inviter can ask
for a different behavior.

If the agent is already in the same meeting, `join_meeting` refuses to send a
second bot; use the existing meeting thread instead. If a saved meeting record
still says the meeting is open but Recall confirms the bot has left or the call
has ended, Genesis records it as closed before deciding whether a rejoin is
needed. If the agent has left a meeting that this person originally requested
from this private conversation, asking to rejoin that same meeting does not
require a second Action Review.

```python theme={null}
join_meeting(meeting_url="https://meet.google.com/abc-defg-hij")
```

### Managing a meeting

For `send_meeting_chat`, `get_meeting_status`, and `leave_meeting`,
`meeting_thread_id` is optional when calling from that meeting's own thread;
otherwise pass the ID returned by `join_meeting`. The owner, a call made from
the meeting thread, or a call from the conversation that asked for the join can
manage it. In a shared conversation, this includes other participants' turns.

| Tool | Parameters | Result |
| - | - | - |
| `send_meeting_chat` | `message` (string, required); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | `sent: true` when Recall.ai accepts the message. Messages are limited to 500 characters on Google Meet and 4,096 on Zoom and Teams; longer messages are refused, not shortened. A repeat is refused with `already_in_chat: true`; answer each line once, and send a second message only for a genuinely new addition, such as a table. |
| `get_meeting_status` | `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Platform, meeting URL, status (`joining`, `in_call`, `left`, `ended`, or `failed`), Recall.ai status, `voice: {state, reason}`, open voice requests, update choice, `meeting_thread_id`, and `asked_from_thread` (the conversation that requested the join, or null for older meetings). Voice `state` is `off`, `starting`, `ready`, `live`, or `failed`; `reason` explains why voice is off or failed. Meeting updates arrive without polling; do not call this repeatedly to wait for news. |
| `leave_meeting` | `meeting_thread_id` (string or null, defaults to the current thread); `rejoin` (boolean, defaults to `false`); context-injected `bot_id`, `thread_id`, and `user_id` | `left: true` when the bot has left; `rejoin=true` requests an immediate return to the same meeting in the same thread and may wait for Action Review approval. |
| `send_meeting_recap` | `recap` (string, required); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, `user_id`, and `input_metadata` | Adds a Slack direct message copy of a recap already posted in the meeting conversation. Available from the end-of-meeting note or when the inviter or an approved person asks; deduplicated in memory per meeting. Requires the inviter's Slack identity, either from the Slack request or a linked account. |

### Reacting and asking for the floor

`react_in_meeting` accepts only the reactions offered by that meeting's platform. When the
meeting stage is connected and the agent's hand is down, the emoji briefly appears on its
video tile; otherwise it is posted in meeting chat (bots cannot send the platform's native
reaction). Zoom supports
`👏`, `👍`, `❤️`, `😂`, `😮`, and `🎉`; Google Meet supports `💖`, `👍`, `🎉`, `👏`, `😂`,
`😮`, `😢`, `🤔`, and `👎`; Microsoft Teams supports `👍`, `❤️`, `👏`, `😂`, and `😮`.

| Tool | Parameters | Behavior |
| - | - | - |
| `react_in_meeting` | `reaction` (string, required); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Returns `shown_in: ["tile"]` when shown on the video tile or `shown_in: ["chat"]` when posted in chat. Refuses unsupported reactions and lists those available for the platform. |
| `raise_hand` | `about` (string, required, 1–120 characters); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Posts a hand-raise notice in chat and shows ✋ on the video tile when connected. Returns `shown_in: ["tile", "chat"]` or `["chat"]`, plus `shown_as` describing what appeared. The hand is lowered when the agent is called on, lowers it, or after three minutes without being called on. Raising it again replaces its topic. |
| `lower_hand` | `point` (string or null, optional); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Lowers an existing hand and clears its tile reaction. A non-empty `point` is posted in chat first; omitting it lowers the hand without posting. If the agent's live voice is on, these tools return `voice_live`; advise the voice instead of acting from the thread. |

These calls read the meeting thread and use Recall.ai to post chat messages. Raising a hand
and lowering it also write the hand state to the meeting thread. A meeting the agent has
left cannot be changed.

### Muting the agent's voice

`mute_myself_in_meeting` lets the agent change its own mute state or turn its
live voice fully off. A person's mute takes precedence, and only that person can
release it. `voice_off=true` stops the voice from speaking or listening, even
when someone addresses it; meeting updates return to the text side. Pass
`voice_off=false` to turn it back on. Omit `voice_off` to change only the tile
mute. For the tile badge and voice behavior, see
[Showing Things in a Meeting](https://docs.genesiscomputing.com/docs/User-Guide/Meeting-Canvas.md).

| Tool | Parameters | Result |
| - | - | - |
| `mute_myself_in_meeting` | `muted` (`boolean`, required); `voice_off` (`boolean \| null`, default `null`); `meeting_thread_id` (`string \| null`, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Returns `success`, `muted`, and `voice_off` when supplied. `voice_off=true` turns the live voice off regardless of `muted`; `false` turns it back on unless a person muted it. A person-muted voice cannot be turned back on by the agent. Cost: one meeting-thread read and stage-page push; supplying `voice_off` also writes the thread state. |

### Changing meeting language

Use `set_meeting_language` to switch the live voice and/or transcript while the agent
stays in the call. The live voice changes language at once and keeps using it in later
sessions. Only the inviter or a participant they approved with a director code can
change the language. A transcript change can briefly interrupt transcript capture;
non-English transcript updates can arrive 3–10 minutes late. Cost: a meeting-thread
read and write and the voice relay; when changing the transcript, one connection read
and two calls to Recall.ai. For the meeting
setup and Recall.ai retention rules, see \[Meetings through Genesis AI]
(/docs/Setup/Setup-AI-Model#meetings-through-genesis-ai).

When the live voice switches its spoken language, it uses that language for the meeting
transcript too unless a transcript language is specified. Use `auto` when people mix languages.

| Parameter | Type | Default | Description |
| - | - | - | - |
| `spoken` | string or null | `null` | Language the voice should speak and understand, by name (for example, `Russian`). Omit to leave the voice language unchanged. |
| `transcript` | string or null | `null` | Transcript language code (for example, `ru`, `de`, or `ja`), `auto` for mixed languages, or `en`. Omit to leave the transcript language unchanged. |
| `meeting_thread_id` | string or null | Current thread | Meeting thread returned by `join_meeting`; omit when calling from that meeting's thread. |
| `bot_id`, `thread_id`, `user_id`, `input_metadata` | implicit | Current context | Supplied by Genesis. |

When a spoken-language change succeeds, the result reports `spoken`, `voice_told`,
and `transcript`; transcript-only changes return `status` and `transcript`. Transcript
status is `switched`, `unchanged`, or `rejoin_needed`. When it is `rejoin_needed`, the
voice has still switched; the response includes the meeting URL, requested transcript
language, and source thread needed to offer a rejoin. If only `transcript` was requested,
the voice continues speaking as before.

```python theme={null}
set_meeting_language(spoken="Russian", transcript="ru")
```

### `follow_meeting`

Meeting speech and chat reach the agent every 30 seconds by default, including
while its live voice is on. A line that names the agent always arrives immediately.
With live voice, saying the agent's name starts a conversation; follow-ups need
no name until the voice stops, turns away, or becomes idle.
Use `follow_meeting` to change how the rest of the call is delivered, or to add
transcript spellings of the agent's name so addressed lines using those spellings
arrive immediately:

| Parameter | Type | Default | Description |
| - | - | - | - |
| `updates` | string or null | `null` | `every_n_seconds` for periodic updates, or `when_named` to hold other updates until the agent is named. Omit to keep the current choice; at least one of `updates` or `also_called` is required. |
| `every_seconds` | integer or null | `null` | With `every_n_seconds`, set the interval from `10` to `600` seconds; omitting it keeps the current interval or uses 30 seconds if unset. Ignored for `when_named`. |
| `also_called` | string\[] or null | `null` | Replace the meeting's alternate names with up to 5 names, each 3–40 characters and not an everyday word. A line addressing the agent by one of these names arrives immediately. Pass `[]` to clear the list; omit to keep it unchanged. |
| `meeting_thread_id` | string or null | Current thread | Meeting thread to change; omit when calling from the meeting's own thread. |
| `bot_id`, `thread_id`, `user_id` | implicit | Current context | Supplied by Genesis. |

Either choice also sends about ten minutes of accumulated talk as soon as it
piles up, and anything not yet heard when the call ends. With the live voice on,
keep the text side up to date and watch for requested follow-ups; do not answer
in the meeting what the voice is handling. In `when_named` mode, the text side
catches up when the voice hands it work, someone writes to it, or the meeting ends.
In `every_n_seconds` mode, an update goes out when its interval is due even if no
one speaks again. A message sent while a meeting update is already running waits
for that turn to finish instead of interrupting it.
Updates do not require a reply. `get_meeting_status` shows the saved choice. For
example:

```python theme={null}
follow_meeting(updates="when_named")
follow_meeting(updates="every_n_seconds", every_seconds=60)
```

The call reads and writes the meeting thread. A meeting you are no longer in, a
value other than the two listed choices, an interval outside `10`–`600`, or a
name list that would not all be kept is refused.

The Recall.ai bot is billed for its time in the call until it leaves. Joining,
leaving, and sending chat make requests to Recall.ai. A status check reads the
meeting thread and connection; Recall status is reused for 10 seconds, so
repeated checks in that window do not make another status request.

### `look_at_meeting_screen`

Use this when someone asks what is on screen or refers to a shared slide, chart,
or document. It reads the latest still from the meeting's screen share and asks
the vision-capable model of the calling thread to describe it or answer a
question. The frame is 360p, so fine print may be unreadable; the agent should
say when it cannot read text rather than guess. The result includes `answer`,
`shared_by`, and `seen_seconds_ago`; when the image is more than 10 seconds old,
it also includes a `note` that the share may have stopped.

| Parameter | Type | Default | Description |
| - | - | - | - |
| `question` | string or null | `null` | What to find out about the shared screen. Omit it to request a description of the whole screen. |
| `meeting_thread_id` | string or null | `null` | Meeting thread to inspect. Omit when calling from the meeting's own thread. |
| `bot_id`, `thread_id`, `user_id` | implicit | Current context | Supplied by Genesis; the calling thread selects the vision model. |

The tool refuses when there is no visible share, the bot has left the meeting,
or the calling model cannot read images. It costs one meeting-thread read and
one vision-model call with the frame attached. For the agent's own live canvas,
see [Showing Things in a Meeting](https://docs.genesiscomputing.com/docs/User-Guide/Meeting-Canvas.md).

### Meeting chat and transcript

| Tool | Parameters | Result |
| - | - | - |
| `send_meeting_chat` | `text` (string); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Posts the agent's reply to the call's meeting chat. |
| `get_meeting_transcript` | `last_lines` (integer, defaults to `200`, minimum `1`); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Newest lines up to the requested count and 12,000 characters, in chronological order, with status, `left_out`, and `complete`. |

The transcript includes speech and meeting-chat messages as they are recorded.
When called from the conversation that invited the bot, pass the
`meeting_thread_id` returned by `join_meeting`; the call itself does not deliver
the agent's response to that conversation. `left_out` counts older lines omitted;
`complete` is false if the server restarted, another server handled the meeting,
or the transcript exceeded its retained history. Reading costs a meeting-thread
properties read. See [Recall.ai connection setup](https://docs.genesiscomputing.com/docs/Setup/Connections.md#recallai-connections).

### Working alongside the live voice

Use these tools from the meeting conversation to coordinate the text agent
with a meeting's live voice. The voice can speak only for the person who
invited the agent; when another participant asks, the response goes to meeting
chat. It follows the same meeting conversation, can post links and other text
in meeting chat, and can mute itself between turns when asked. Use
`send_meeting_chat` for long answers, tables, or links rather than trying to
speak them. A chat post is not a spoken answer: for a question asked aloud,
give the voice its one-line spoken summary even if the details are already in
chat. It does not post that summary again. If it could not speak the answer, the
task stays open. For a temporary reason, retry with the same `task_id` when that
reason no longer holds. A `refused` outcome is not temporary: do not retry that
task. If the answer is for the whole call and nothing is private, post it once
with `send_meeting_chat`; if it is already in chat, do not post it again. Keep
private information out of meeting chat.
When its work takes longer than an immediate answer, it can hand
that work to the meeting conversation and speak the result when it returns. Work the
inviter or an approved director asks for can continue across later turns of that meeting:
the agent may update the same Linear issue or Google Doc without a new request, but the
standing grant does not cover a new item or a different target. Before answering what it
did in this meeting, the voice checks its own work record for tickets
and links, chat posts, queries, canvas items, and work still in progress. The inviter or
an approved director can see the full record; other participants see only what the chat
already shows. See [Showing Things in a Meeting](https://docs.genesiscomputing.com/docs/User-Guide/Meeting-Canvas.md) for
how the live voice behaves through quiet periods. If
the same spoken line is handed off again while its task is open, the second
handoff revises that task; the agent gives one answer covering both readings.

| Tool | Parameters | Result |
| - | - | - |
| `tell_meeting_voice` | `message` (string, required; up to 600 characters); `task_id` (string or null, optional; the `vt-...` task the voice handed off); `urgent` (boolean, defaults to `false`); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, `user_id`, and `input_metadata` | With `task_id`, gives the voice an answer to say once, in a pause; `urgent=true` asks it to speak when its current sentence ends. Without `task_id`, gives it advice to use or ignore. `outcome` is `queued`, `suggested`, `duplicate`, `muted`, `standing_by`, `no_session`, or `refused`. `standing_by` means someone in the call told the voice to stop speaking; it says nothing until someone names it again. If the voice cannot say a task answer, nothing is posted (`posted_in_chat: false`); `why` and `next` explain what happened. A refused task stays open and is refused again on retry; follow `next` rather than retrying. If the answer is already in chat, `already_in_chat: true` means it was not spoken; do not repost it. A chat post alone does not complete a spoken answer. |
| `note_meeting_work` | `note` (string, required; 1–300 characters); `status` (string, defaults to `working`; `working`, `waiting_on_you`, `needs_approval`, `done`, or `failed`); `task_id` (string or null, optional; a `vt-...` task or a `tt-...` task returned by this tool); `taken_from_call` (boolean, defaults to `false`); `meeting_thread_id` (string or null, defaults to the current thread); context-injected `bot_id`, `thread_id`, and `user_id` | Gives the voice a short progress update to use as context; it does not ask the voice to speak. Set `taken_from_call=true` when taking up a request the voice observed but did not start; this tells the voice privately that the text side has taken it. Returns the task id and whether the voice is live. |

Call `note_meeting_work` before starting unassigned work for the meeting, then
use its returned task id to update progress. For a request the voice missed, first
set `taken_from_call=true` and say briefly that you are working on it; then give the
completed answer with `tell_meeting_voice`, not as a progress note. The voice can
observe exchanges and hand missed requests to the text side. It sends the answer in
the next pause when it can; if it cannot say it, nothing is sent to the call.

```python theme={null}
note_meeting_work(note="Checking the quarterly totals")
tell_meeting_voice(message="The totals match the forecast.", task_id="vt-...")
```

### `get_meeting_participants`

Use this to check who is in the call or whether a named person has joined. Meeting joins and
leaves are also relayed with the agent's meeting updates; updates arrive at once while its
live voice is on.

| Parameter | Type | Default | Description |
| - | - | - | - |
| `meeting_thread_id` | string or null | `null` | Meeting thread to inspect. Omit when calling from that meeting's own thread. |
| `bot_id`, `thread_id`, `user_id` | implicit | Current context | Supplied by Genesis. |

The result includes `in_call` and `left` arrays. Each person has `name`, `host`, and `since`
(an ISO UTC timestamp); for a departed person, `since` is when they left. The agent is not
listed. `complete` is false when Genesis began monitoring after the meeting started, so a
quiet participant may not appear until they speak, type, join, or leave. The call reads the
meeting thread's properties; the roster itself is held in memory.

### `meeting_director_code`

Joining a meeting sends the inviter a one-time code privately when Genesis can
deliver one. Use this tool only when they need a new code (for example, the
previous code expired) or when the inviter asks to let another participant
direct the agent. A display name in a meeting is not proof of identity. The
inviter or approved participant types the code, alone, into meeting chat;
whoever posts it is bound to that meeting participant, and the code is used
once. Genesis never gives the code to the agent.

| Parameter | Type | Default | Description |
| - | - | - | - |
| `for_whom` | string or null | `null` | Optional label for the approved participant. The code still goes privately to the inviter to pass on. Maximum 80 characters. Omit for the inviter's own code. |
| `meeting_thread_id` | string or null | `null` | Meeting thread returned by `join_meeting`. Omit when calling from the conversation that holds the meeting. |
| `bot_id`, `thread_id`, `user_id`, `input_metadata` | implicit | Current context | Supplied by Genesis. A request for another participant's code must come from the inviter's own private Genesis conversation. |

The result says who received the code privately and how long it lasts; it never
contains the code. Genesis delivers it by Slack direct message when the inviter
asked from Slack, otherwise in a private Genesis chat card that only the inviter
can open. It expires after 10 minutes and works once. At most five unused codes
can wait for one meeting. A request for another participant's code is accepted
only from the inviter's private Genesis chat; other callers are also refused
while an unused inviter code is waiting. For setup and the preview setting, see
[Recall.ai connections](https://docs.genesiscomputing.com/docs/Setup/Connections.md#recallai-connections).
Issuing a replacement costs two or three thread-properties reads, a read of the
requesting conversation's message metadata, a user read, one conditional thread
write (up to three attempts if the meeting thread changes concurrently), and a
Slack message or Genesis chat card. The web chat card reveals the code once to
its owner and offers a replacement if it expires or has already been shown.
The shared link in the meeting greeting lets each signed-in person with agent
access request their own code; a participant's code allows only actions within
that person's access. The code must arrive in meeting chat as plain text. The
chat card's **Copy** button and copying the displayed code copy plain text,
avoiding Teams' rich-text paste behavior. If the inviter asks for their own
code again from their private Genesis conversation, an unused previous code is
replaced and stops working.

```python theme={null}
meeting_director_code(for_whom="Priya", meeting_thread_id="meeting_abc123")
```

After a person types their code in a Zoom or Microsoft Teams meeting they
invited the agent to, Genesis remembers that account as theirs in later meetings
they invite the agent to; they do not need another code for those accounts.
Use `forget_meeting_accounts` when the person asks Genesis to stop recognizing
their meeting accounts. It forgets only that person's account records; pass
`platform="zoom"` or `platform="microsoft_teams"` to forget one platform, or
omit `platform` to forget both.

### `record_meeting_consent`

Call this only after asking a signed-in participant in the meeting chat whether
the agent may answer other participants' questions using data that person can
see. The participant must reply with a plain yes in their own turn; quote that
reply exactly. The tool refuses a reply from another person, a conditional yes,
or a yes that was not given in response to the recent question. A successful
record applies for the rest of the meeting while that participant remains in
the call. From then on, other people's read-only questions can use that
participant's access; other actions are not authorized by this consent. A fixed
chat line tells everyone when consent is recorded.

| Parameter | Type | Default | Description |
| - | - | - | - |
| `participant_reply` | string | required | The participant's exact reply, such as `yes, go ahead`. |
| `meeting_thread_id` | string or null | `null` | Meeting thread returned by `join_meeting`; omit from the meeting's own thread. |
| `bot_id`, `thread_id`, `user_id`, `input_metadata` | implicit | Current context | Supplied by Genesis; the request must come from the participant's own turn in the meeting thread. |

Returns `recorded` and `in_effect`. If it was recorded but cannot apply now,
`in_effect` is `false` and the result says why; repeat that reason briefly in
the meeting chat. Example:

```python theme={null}
record_meeting_consent(
    participant_reply="Yes, go ahead.",
    meeting_thread_id="meeting_abc123",
)
```

### `forget_meeting_accounts`

| Parameter | Type | Default | Description |
| - | - | - | - |
| `platform` | string or null | `null` | `zoom` or `microsoft_teams`; omit to forget both platforms. |

The tool forgets only the person in the current conversation. It returns the
number of accounts forgotten; if the settings write fails, it reports that the
accounts remain remembered. Forgetting costs a user read and, when an account
was remembered, a settings write.
