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 and the
Recall.ai event endpoint.
Enable the meeting_tools group for the agent.
Actions
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 includescanvas_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.
Show and fetch content
canvas_browse, canvas_preview, and canvas_query share a 30-second quick-read limit.
See the live canvas guide 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:
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
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.
join_meeting
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.
Managing a meeting
Forsend_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.
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 😮.
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.
Changing meeting language
Useset_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.
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.
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:
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:
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.
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.
Meeting chat and transcript
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.
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. Usesend_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 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.
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.
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.
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.
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.
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.
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.
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:
forget_meeting_accounts
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.

