ask_coach
ChatGPTThe right tool for open-ended coaching questions: what to improve, why a score changed, what is blocking a belt promotion, or general coaching guidance across one call or many. Ask in plain language and get back a synthesized answer grounded in your real session data, with citations back to the sessions it used, reasoned across your history instead of one row at a time. Prefer this over pulling raw scores or measurements yourself and reasoning about them: this tool already does that work and cites its sources. With the team permission granted, you can also ask about a teammate or your whole team. Belt level is always whole-rapport, never a single dimension.
assign_speaker
ChatGPTGive a name to one or more voices in a conversation, and say which one is the caller themselves. Analysis starts only when every voice is assigned and one is marked as the caller. A partial label save does not start analysis. Pass defer_analysis true when get_next_step asked you to label first and verify later. Pass one entry per voice you are naming; set is_self true on at most one of them, for the voice that is the caller. Setting is_self also marks every other voice as the other side, except a teammate already on your side. Set role on the other voices when the calendar and transcript make it clear (team_member for a colleague on the caller's side, primary_contact for the main other party, secondary_contact for additional outside voices). Set side your_side only for the caller or a teammate (role team_member); everyone else is their_side. If the caller says a voice is not a real person, an ad, a video playing, a recording, a synthetic or AI voice, set role media on that entry (with any name they like, such as AI voice) so it is kept out of conversation measurement.
attach_session_metadata
ChatGPTAdd missing details to a conversation: how it turned out, free-text context about it, or its title. The outcome question depends on the conversation's type. Sales-type conversations (sales calls, client consultations, negotiations, vendor partnerships, recorded sales pitches) ask win or loss. Every other type asks whether the person got what they came for, answered achieved, partial, or missed; phrase it against the conversation's stated goal when one is known, never as win or loss. If they add a sentence about why, pass it as outcome_note. Give at least one of outcome, context, title, conversation_type, or team_scope_team_id. Ask the caller in the same breath as any speaker question so they only get asked once. conversation_type on a call that is already analyzed is refused; use start_analysis with confirm_reanalysis instead. team_scope_team_id marks this call as belonging to one of the caller's teams, or null if it is not a team call. The resolver will not override that choice.
capture_session_feedback
ChatGPTStore what the person says about their own call, in their own words. Use it when they ask how a call went, mention one they just finished, or react to one out loud. Flip the question before you answer it. Ask how it felt, open-ended, no scale, and store their answer with step raw_read. Then ask what part is sticking with them and store that with step flagged_moment, passing t_ms when they point at something you can locate with list_session_moments. Do both of those BEFORE you read this session's scores with get_session_overview, get_session_scores, get_session_communication, get_session_measurements, or ask_coach. What a person says before they have heard the number is a different reading from what they say after, and the server records which one it was on every note. Fetching the score first turns every answer of the day into the second kind. Then deliver the score, leading with where it agrees with what they already told you, so the disagreement is worth something when you reach it. Then name one stretch the system flagged that they did not mention, ask about it, and store their answer with step divergence_response and that stretch's t_ms. Last, read the action items back and store any correction with step action_item_corrections. Stop wherever they stop. Each step is saved on its own the moment you send it, so someone who answers one question and walks away still leaves something worth having. Two optional extras, seconds each: a confidence number from 0 to 100 with step confidence, and where they think the relationship stands with step relationship_read. Send what they actually said, close to verbatim. Never your summary of it, and never your own read of how they were feeling. This tool only stores their words. It never changes a score, a measurement, or an action item.
connect_calendar
ChatGPTCheck whether a calendar is connected for automatic meeting capture. If none is connected, returns a link and plain-language instructions for the human to connect one.
get_moment_evidence
ChatGPTGet the transcript around a moment in one of your sessions, so you can quote what was actually said. Give either t_ms or a moment_id from list_session_moments. Returns the utterances in the window plus a player link.
get_next_step
ChatGPTDrive an upload through to an analyzed call. Returns the single next action, complete arguments, and one session-wide list of questions to ask the user. Call this first when the user wants to upload, finish, or analyze a recording. Then do exactly what next_action says. Never guess conversation type or outcome. After speakers and details are set, call verify_session_setup and read it aloud before start_analysis.
get_progress
ChatGPTGet your whole-rapport belt progression history, your latest personal baseline snapshot, and next_belt_gate: a one-call deterministic answer to what is blocking your next belt, listing each dimension score still below the next belt's threshold plus whether a roleplay is still required. This returns data points, not an explanation. For why a trend moved or what to work on next, use ask_coach instead: it reasons across your history and returns a synthesized, cited answer rather than rows you would interpret yourself.
get_session
ChatGPTGet one of your sessions by id, including its current processing status.
get_session_communication
ChatGPTGet the detailed communication analysis for one of your sessions: clarity, pace, turn-taking, questions, listening, interruptions and affirmations, plus the speaker roster.
get_session_coverage
ChatGPTCheck which analysis layers exist for one of your sessions (transcript, scores, communication, moments, measurements, prosody, action items) plus quality flags. Call this before presenting a confident read, so you never coach on a missing layer.
get_session_measurements
ChatGPTGet raw graduated measurement detail for ONE session, as unexplained numbers. Only measurements that have graduated to customer-facing status are returned. Use this only when you already know which single session and which measurement keys you need. This is not the tool for open-ended coaching or belt questions such as why a score changed, what is blocking a belt, or what to improve: use ask_coach instead, it reasons across your sessions and returns a synthesized, cited answer.
get_session_overview
ChatGPTGet the debrief bundle for one of your sessions: rapport overall plus the 7 dimensions, communication composite, talk time, patience, pace, questions, longest monologue, commitments made in the call, primary action item, a separate coaching-tip field, and what you did well versus what to work on first. The bundle now also carries the meeting summary for the conversation (objectives, outcome, discussion points, decisions, next steps and per-participant effectiveness), so you can open a debrief on what the meeting was about before quoting any number.
get_session_scores
ChatGPTGet the raw graduated rapport scores for ONE session (overall score plus the seven dimension scores), and nothing else: no explanation, no trend, no citations. Use this only when you already know which single session you need numbers for. For anything open-ended, coaching, or belt-related, such as what to improve, why a score changed, or what is blocking a belt, use ask_coach instead: it reasons across calls and returns a synthesized, cited answer instead of rows you would have to assemble yourself.
get_speaker_labeling_task
ChatGPTCall this when the user wants to finish, complete, fix, or label a call, or asks who was on a call that is not done yet. Read what a parked conversation still needs so you can finish it out loud with the person. Only works on a conversation that is waiting for speaker labels; anything else returns an empty needs list, not an error. For each unlabeled voice, you get a short list of candidate names (from the calendar invite, not from the audio) and up to three of that voice's longest, clearest lines from the transcript. When voice_sample_urls is present, play one of those clips to the person and ask whose voice it is; when it is absent but media_fragment_url is present, play that instead, starting playback at its #t=start,end marker. That marker is a player hint only, not a scope limit: the underlying link is a signed URL to the FULL session recording, not a pre-cut sample, so treat it with the same care as voice_sample_urls and start playback exactly where the marker says rather than from the beginning. When neither is present, read a line or two of the transcript quotes aloud instead. Before asking anything, use caller_display_name (the account owner's own name, on the response) with the candidate names and the transcript quotes to work out which voice is the caller and who the others are yourself, so you can name most or all voices without a question; ask only what you genuinely cannot infer. When you do ask, ask ONE question per voice, not a mechanical read of the whole candidate list, and ask ONE consolidated question per session, not one per voice. Both URL fields are short-lived signed links scoped to this caller's own conversation; never repeat them back as text, never log them, and never carry a raw storage path or any signal computed from the voice itself, only a link to listen. If every voice already has a name but nobody is marked as the account owner, you get a roster instead; match caller_display_name to one of the named voices and mark that one the caller, asking only when the name does not clearly point to a single voice. The response also carries outcome_vocabulary, which register the outcome question uses when you bundle it into the same consolidated question: win_loss means ask win or loss, goal_attainment means ask whether they got what they came for (achieved, partial, or missed).
get_srt_transcript
ChatGPTGet the COMPLETE transcript for one of your sessions as a standard SRT (SubRip) document: numbered cues, HH:MM:SS,mmm timestamps, a speaker name on every cue. Save it as a .txt file (SRT content, text extension, so it opens in any editor).
get_team_overview
ChatGPTRead the team coaching overview visible to a team lead: named per-member composite scores, trends, and skill breakdowns, the same aggregates a lead sees on the team dashboard. If the connected user does not lead a team, returns a no-team result rather than any other team's data. This tool never returns per-moment coaching text or moment quotes: no detector behind that material has a measured accuracy today, so it is withheld at the source rather than flagged with a status. In its place, momentsPendingValidation carries a count per member and a deep link (/dashboard?tab=team) where the lead can review moments in the app. Theme fields (whatWentWellThemes and its siblings) are returned as bare counts, not sample text, for the same reason. coachingPriority.urgency is never "critical" or "high" from fewer than 3 scored sessions: below that floor it reads "insufficient_data" instead.
get_team_report
ChatGPTFetch one generated team report by report_id. Default (mode report, format link) returns metadata plus report_url, the link to give a person: it opens the report as a rendered page in the RapportScore app after sign-in, only for platform administrators and the coaches of that team, and it does not expire. Every report-mode result carries report_url, including format text. It also returns the report label and sequence number, the earlier report it was compared against, the loader and template versions, and whether a stored data payload exists. The payload itself is never returned here. Set format to text to receive headed plain text with a table of contents (about 17k tokens). With format text, section picks one h2 by 1-based index or a title substring. Set include_html to true to also receive the report HTML; it is about 560 KB and may be cut off, so prefer format text. Set mode to delta to receive the stored before-and-after comparison for this after-report (the earlier window versus the later window), computed in code and written under the report's guards, plus delta_page_url, the link to give a person: it opens the comparison as a rendered page in the RapportScore app after sign-in, for the same people as report_url. Member ids are replaced with display names. Available to platform administrators and the coaches attached to a team: a coach may read only a report whose team they coach, never a cohort report. Other users receive a denial.
get_team_session_recap
ChatGPTGet a summary, decisions, and action items for one session owned by a member of a team the connected user leads, computed only from the counterpart's (their_side) speech, never the member's own words. Not-found for a session outside the led teams, for a session with no recap yet, and for a garbage id, all with the same response so none is distinguishable from another.
get_training_links
ChatGPTGet direct links to training for the connected user: for each rapport dimension currently blocking the next whole-rapport belt (or one requested dimension), the foundational lesson and the belt-appropriate deeper lesson, plus a numbered next_steps list. Always present next_steps as a numbered 1-2-3 list, visually distinct from the prose. Item 1 is the primary action: start a live roleplay with Ask Alex. Do not bury these as trailing inline links. This tool returns links and lesson titles, not advice: for what to work on and why, use ask_coach.
get_transcript
ChatGPTGet the structured transcript for one of your sessions, paged by sequence (the agent-native format). For a downloadable document use get_srt_transcript (SRT) or get_vtt_transcript (turn-coalesced WebVTT with speaker voice tags) instead.
get_vtt_transcript
ChatGPTGet the COMPLETE transcript for one of your sessions as turn-coalesced WebVTT: consecutive same-speaker utterances merged into floor-based turns (a long monologue becomes ONE long cue), standard <v Speaker> voice tags, HH:MM:SS.mmm timestamps. The turn-level human export; spec-valid WebVTT, though built for reading rather than caption display.
list_session_moments
ChatGPTList the timestamped moments in one of your sessions, merged from rapport moments, coaching moments, deterministic timing events, questions and objections. Each moment carries the speaker (label and name where the session has one) and a transcript span you can pull with get_moment_evidence. Times are milliseconds from session start. Filter by type or source; an unrecognised type comes back naming the valid ones with counts. Also returns per-type counts and repeat-behaviour rollups.
list_sessions
ChatGPTList your conversation sessions, optionally filtered by date range, status, or conversation type.
list_team_counterparts
ChatGPTFor a team lead: list the outside people (customers, prospects, partners) that members of the teams you lead have spoken with on recorded calls, by the name recorded on those calls. Each entry has how many calls that person was on, the date of the most recent one, and which team members met them. Use it to answer questions such as who on my team has talked to Acme. It returns names only: no email addresses or other contact details, no scores, no transcripts, no quotes. Only calls already recorded by the lead's own teams are read; if the connected user does not lead a team it returns not found. If truncated is true, more calls exist in the window than were scanned, so shorten days_range.
list_team_reports
ChatGPTList generated Team Intelligence Reports, newest first, one row per generated render. Available to platform administrators and the coaches attached to a team: other users receive a denial. Administrators see every team; a coach sees only the teams they coach and never an internal_test row. Returns report ids, the team or cohort each report covers, the data window, the sufficiency band, the report label and sequence number, the baseline it was compared against, the loader and template versions, and whether a report page and a stored data payload exist. Use get_team_report with format text to read one report as headed text, or omit format for report_url, the rendered page to give a person.
list_team_sessions
ChatGPTList sessions across the teams the connected user leads: one row per call with the owning member's name, session id, date, title, conversation type, duration, outcome, and the counterpart names on that call (their_side, from session_speakers). No scores, no transcripts, no moment text, no member quotes. If the connected user does not lead a team, returns the same not-found result a foreign id would. truncated: true means more sessions exist in the window than the row cap returned; narrow days_range or member_ids.
list_uploads
ChatGPTCall this whenever the user asks anything shaped like: does anything need my attention, is something waiting on me, are my calls or recordings done, what should I do next, or why is a session stuck. It answers all of those. Each entry's needs list is an action the USER must take; say each need in plain speech (speaker_labels means this call needs you to say who was speaking, focus_speaker means tell me which person is you, outcome means how it turned out (each entry that needs one carries outcome_vocabulary: win_loss means ask win or loss, goal_attainment means ask did you get what you came for and answer achieved, partial, or missed), context means one sentence about the call, team_scope means ask Was this a <team> call yes or no and send the team id or null on attach_session_metadata), never the raw code. See the whole active picture of your uploads in one call: every session that is still in flight, plus anything that finished or failed in the last 7 days, each with a display_state (uploading, transcribing, awaiting_speaker_id, analyzing, completed, or failed) and a needs list. Entries are not all the same shape: outcome and context are plain strings meaning that field is blank, while an unlabeled diarization label is an object like {need: "speaker_labels:B", candidates_ready: true}, where candidates_ready true means voice evidence clips are cut and get_speaker_labeling_task will serve them. This is what turns polling get_session one id at a time into a single answer like "7 of 9 done, 2 awaiting speaker labels", and it is the read to run after uploading a batch to confirm state changes without the human returning to the app. Also returns remaining_allowance, the same remaining-minutes figure upload_conversation's declared_duration_minutes check uses. Autonomy floor for driving a batch from here: one confirmation per batch before upload starts, since uploads are metered spend and the recordings contain other people; below that, no interaction unless the needs list forces it.
share_session
ChatGPTShare one of the user's analyzed calls with a person who was ON that call, by email. Creates the share link and sends it through email in one step, with the claim framing: thanks for being on this call with me, I have shared how I scored, claim the call to see how you did and get a free trial. Without recipient_email, the saved email is resolved from the call's own participants (linked account, guest profile, calendar invite, meeting roster) and the resolution source is returned; pass recipient_email only when the user names a different address. Use this when the user says to share a call, send the call to someone, or promised someone on the call a link. Only the session owner can share, only people on the call can be resolved automatically, and repeated asks re-send the same link rather than minting a new one.
start_analysis
ChatGPTStart the full analysis of a conversation after verify_session_setup has been read aloud and the user said yes. This is the only new tool that starts the pipeline. On an already analyzed call it requires confirm_reanalysis.
upload_conversation
ChatGPTAdd a recorded conversation for analysis. Provide a direct https link to an audio or video file with file_url, or set mode to request_upload_url to get an upload link for raw bytes and then call again with mode complete. For request_upload_url, small files default to a single PUT; set upload_protocol to tus (or declare file_size_bytes at or above 50 MB) to get a resumable TUS handshake instead, so a multi-GB upload that drops partway through resumes rather than restarting from zero. A request_upload_url response includes upload_deadline (about two hours from the call, matching the signed upload link). Finish before that time: a shell not completed by then is removed automatically. If you start the same recording again (same title or file_name) while that empty shell is still open, the call reuses that session_id and sets reused_session true rather than creating a duplicate. If complete reports that no file was found, call request_upload_url again instead of retrying complete. Either mode accepts declared_duration_minutes to have the batch checked against your remaining processing allowance before anything starts: if it plainly will not fit, the call is refused upfront with the real numbers rather than started and left to strand partway. Returns a session_id you can poll with get_session, or track alongside every other in-flight upload with list_uploads. After ingestion the recording transcribes and then PARKS at awaiting_speaker_id, waiting for speaker labels before any analysis runs, so it is not analyzed yet at that point: do not tell the caller the analysis is running or done until you have labeled the speakers. When it reaches awaiting_speaker_id (visible on get_session or list_uploads), finish it: call get_speaker_labeling_task, work out which voice is the caller from caller_display_name and the calendar candidates and mark them is_self with assign_speaker (which sets their side automatically), name and where you can tell role the other voices, and set outcome and type with attach_session_metadata. Infer as much as you can from the calendar and transcript and ask the caller only what you genuinely cannot work out. Pass conversation_type here at upload time when you already know it, so it does not have to be asked later. If you can attach a file, use request_upload_url then complete. If you can only pass links, ask the user for a direct https link to the recording (a Zoom cloud recording download link works; a Google Drive share link does not). If neither, tell the user to upload in the RapportScore app and come back, then continue from the next step. Then call get_next_step.
verify_session_setup
ChatGPTRead back who is who, which side each person is on, who the caller is, the conversation type, the outcome, and the context, in plain speech. Call this after speakers and details are set, read the summary aloud, and only then call start_analysis if the user says yes.
whoami
ChatGPTLook up your RapportScore profile: whole-rapport belt level, subscription plan, remaining credit hours, whether a calendar is connected, coach_of (the teams the caller currently coaches), and pending_actions, a count of recordings waiting for the user's input. When pending_actions shows anything waiting, tell the user even if they did not ask, and offer to walk through it (list_uploads has the details). A raw profile lookup, not coaching guidance: for what is blocking your next belt or what to work on, use ask_coach instead.
