kinevo_add_cardio_to_session
ChatGPTAdd an aerobic (cardio) block to a workout session — continuous (time or distance target: treadmill, bike, outdoor run…), interval (work/rest × rounds), or phased (a SEQUENCE of phases executed in order — e.g., 10min Z1 warmup → Tabata → 5min Z1 cooldown; also different interval blocks back-to-back, or a continuous session with varying intensities). Use inside standalone aerobic sessions (session_type='cardio') or at the end of a strength session. Prefer STRUCTURED intensity over free text: zone (Z1–Z5, resolved to the student's bpm range via max heart rate), hr_min_bpm/hr_max_bpm, target_rpe, or pace_min_per_km. For intervals, prefer a named protocol (tabata, hiit_15_15, hiit_30_30, hiit_40_20, norwegian_4x4 — see kinevo_list_training_methods) which fills work/rest/rounds + suggested intensity in one shot. PERIODIZATION: when the plan changes week by week (e.g., long-run distance building 6→15 km, or fartlek weeks then tempo weeks), pass progression — NEVER describe week-by-week targets in notes; the app resolves the current program week and shows the student that week's target automatically. The student executes with a guided timer in the app (phased runs each phase in sequence).
kinevo_add_exercise_to_session
ChatGPTAdd an exercise to a workout session. Supports both simple prescription (sets + reps + rest) and advanced per-set prescription (set_scheme) with different reps/load/rest per set, training methods (pyramid, drop-set, cluster, 5x5, top+backoff) and per-set load targets (kg or %1RM). Call kinevo_list_training_methods to see method presets. To group exercises into a superset, use kinevo_create_superset instead.
kinevo_add_exercise_to_session
ChatGPTAdd an exercise to a workout session. Supports both simple prescription (sets + reps + rest) and advanced per-set prescription (set_scheme) with different reps/load/rest per set, training methods (pyramid, drop-set, cluster, 5x5, top+backoff) and per-set load targets (kg or %1RM). Call kinevo_list_training_methods to see method presets. To group exercises into a superset, use kinevo_create_superset instead. WEEKLY PERIODIZATION: pass progression on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week.
kinevo_add_group_members
ChatGPTAdd students to a group. Students already in it are skipped (no duplicates). A student who had left and comes back gets a fresh membership, preserving the earlier history.
kinevo_add_note_to_session
ChatGPTAdd a free-text NOTE block to a workout session — an instruction the student reads inside the workout, between exercises (e.g. 'Aquecer a série de trabalho antes do primeiro set pesado', 'Se a dor no ombro aparecer, pare a série'). A note is not an exercise: it has no sets, reps or rest. For a per-exercise instruction use the notes field of that exercise instead; for a warmup routine use kinevo_add_warmup_to_session.
kinevo_add_warmup_to_session
ChatGPTAdd a WARMUP block to a workout session. Three modes: 'text' (a written routine — the legacy and simplest form), 'list' (a flat list of drills, each with its own target and video) and 'bands' (the same drills grouped into named bands, e.g. Liberação → Mobilidade → Ativação → Integração). Prefer 'list'/'bands' over 'text' when you know the drills: only structured drills give the student a per-drill timer and the block an estimated duration. The warmup is always a ROOT item of the session — it is never a station inside a superset or circuit.
kinevo_add_workout_session
ChatGPTAdd a new workout session (e.g., 'Treino A - Peito e Triceps') to an existing program. Works for both templates and assigned programs. RECOMMENDED: also pass scheduled_days to place the session on specific weekdays — a well-prescribed program tells the student which days to train each session, which drives the student's weekly calendar and reminders.
kinevo_add_workout_session
ChatGPTAdd a new workout session (e.g., 'Treino A - Peito e Triceps') to an existing program. Works for both templates and assigned programs. RECOMMENDED: also pass scheduled_days to place the session on specific weekdays — a well-prescribed program tells the student which days to train each session, which drives the student's weekly calendar and reminders. Leave it EMPTY for an EXTRA session ("treino avulso", home/backup workout, optional) in a program whose other sessions have days: the app shows it as "Extra", available any day and outside the weekly goal. For a standalone aerobic session (e.g., 'Treino C - Aeróbio Zona 2'), pass session_type='cardio' and fill it with kinevo_add_cardio_to_session blocks (no strength exercises).
kinevo_apply_auto_progression
ChatGPTAUTOMATIC WEEKLY PROGRESSION for strength exercises: from one rule ('+1 rep por semana', '+2,5 kg por semana', '+1 série', '−10s de descanso', 'deload na semana 4') it generates weeks 2..duration_weeks for every exercise in scope, written as the same weekly overrides the trainer would set by hand. USE THIS instead of writing progression week by week with kinevo_update_workout_item when the trainer asks for a linear/automatic progression. Rules: week 1 is the exercise as prescribed; per-set loads, RIR and tempo are kept in every week; sets never change in named methods (5x5, pyramid, top+backoff, drop-set, cluster) and only change in a superset when the whole block is included; timed sets (plank) are skipped; warmups, cardio and notes never enter. In a deload week the progression pauses and resumes from where it stopped. Requires the program's duration_weeks — if it is missing the tool refuses: ask the trainer, do not pick a duration. Returns, per exercise, applied / kept (hand-made progression, conflict='keep') / skipped (reason) and the generated weeks.
kinevo_apply_group_stage
ChatGPTApply a stage's template to the group's students — each student gets their OWN COPY of the program, which they can then diverge from. This CREATES PROGRAMS FOR REAL STUDENTS and notifies them. ALWAYS call it first WITHOUT confirm to get the preview (which classifies every member: who would be replaced, who is blocked, who is already queued), show that to the trainer, and only call again with confirm=true after explicit approval.
kinevo_archive_class_slot
ChatGPTArchive a class (turma): it stops being offered and no one new can join. It does NOT cancel the students already enrolled — their sessions keep happening. To take a student out, end that student's routine with kinevo_cancel_appointment_series. Tell the trainer this before archiving.
kinevo_archive_student
ChatGPTArchive (offboard) a student who stopped training: cancels their active contracts/subscriptions (including Stripe), optionally ends their recurring appointment routines, ends the trainer-student link and notifies the student. In a STUDIO any active member (trainer or manager) can archive any student of the organization, not only the one responsible for them. The workout HISTORY is preserved and the student moves to the archived list — they can be brought back later with kinevo_reactivate_student (canceled contracts/routines do NOT come back automatically). This is NOT the same as kinevo_update_student status='inactive' (which just marks the student inactive, keeping contracts and the link). Without confirm=true it only returns a PREVIEW (contracts/routines that would be affected). If the student has active appointment routines and appointment_decision was not given, it returns needs_appointment_decision — ask the trainer whether to cancel or keep them, then call again.
kinevo_assign_program
ChatGPTAssign an existing program template to a student, creating a copy. Or activate a draft assigned program by setting its start date.
kinevo_assign_program
ChatGPTAssign an existing program template to a student, creating a copy. Or activate a draft assigned program by setting its start date.
kinevo_cancel_appointment_occurrence
ChatGPTCancel a single scheduled session occurrence (not the whole routine). The student is notified. To end an entire recurring routine, use kinevo_cancel_appointment_series.
kinevo_cancel_appointment_series
ChatGPTEnd an entire recurring routine from a given date onward (default today). Occurrences after the end date stop appearing. The student is notified. To cancel just one session, use kinevo_cancel_appointment_occurrence.
kinevo_cancel_contract
ChatGPTCancel a student's contract. For online (Stripe/Asaas) contracts this also cancels the subscription at the provider. cancel_at_period_end=true schedules the cancellation for the end of the paid period (student keeps access until then); false cancels IMMEDIATELY (access is revoked now). HIGH IMPACT and hard to undo. Call WITHOUT confirm first to preview; call again with confirm=true only after the trainer approved.
kinevo_convert_lead
ChatGPTConvert a lead into a real student account (courtesy / no contract — billing can be set up later with kinevo_create_contract). This CREATES a login account and returns a ONE-TIME, short-lived activation link the trainer sends to the student so they set their OWN password. No password is ever returned. Idempotent: a lead already converted (or whose e-mail already exists under this trainer) just links to the existing student, with no new link. Call WITHOUT confirm first to preview; call again with confirm=true only after the trainer approved.
kinevo_copy_workout_sessions
ChatGPTCopy one or more SESSIONS (workouts) from any of the trainer's programs — any status, including COMPLETED ('previous program') — into another program (draft, scheduled or active), of the same or another student. Copies everything in one transaction: exercises, per-set schemes, supersets/circuits, aerobic blocks, warmups, notes, progression and the session type. The copies go to the END of the target program. Use kinevo_get_program to read the source sessions' ids and the target program id. On an ACTIVE target this becomes an edit card the trainer approves. To copy a WHOLE program use kinevo_duplicate_program instead.
kinevo_create_appointment
ChatGPTSchedule a training session for a student. Set frequency='once' for a single session, or 'weekly'/'biweekly'/'monthly' for a recurring routine that repeats on the weekday of starts_on. The student gets a reminder push and an inbox notification automatically. Overlapping sessions at the same time are allowed (group/duo classes).
kinevo_create_assessment_session
ChatGPTOpen a physical assessment session for a student. Pick template_id via kinevo_list_form_templates with category='assessment'. Returns session_id — then record data with kinevo_save_assessment_measurements and close with kinevo_finalize_assessment. Omit scheduled_at to start an assessment right now (in_progress); set it to schedule for later.
kinevo_create_class_slot
ChatGPTOpen a new class (turma) with a fixed weekday, time and number of spots, with no student yet. It repeats weekly. Students are added afterwards with kinevo_create_appointment (appointment_group_id = the new class id, same weekday and time). Confirm title, day, time and spots with the trainer before calling. Solo/personal accounts only.
kinevo_create_contract
ChatGPTSet up a MANUAL billing contract linking a student to a plan (or courtesy/free access). This CANCELS the student's current active contract and creates the new one. It does NOT charge the student — it just records the billing arrangement. Call WITHOUT confirm first to get a preview of exactly what will happen, then call again with confirm=true only after the trainer approved.
kinevo_create_dated_workout
ChatGPTCreate a NEW, EMPTY session that happens on ONE date only — the 5 km race on Saturday, the 1RM test, a session that does not repeat. It is born with NO weekday, so it never enters the weekly recurrence; it counts once, on that day. Fill it afterwards with kinevo_add_exercise_to_session (strength) or kinevo_add_cardio_to_session (aerobic), exactly like any other session. Do NOT use this to change what an EXISTING session does on one day — that is a different thing (the trainer does it in the calendar, which copies the session for that day). Do NOT use it for an EXTRA workout available any day ("treino avulso", "em casa para quando não puder ir", "reserva") — that is kinevo_add_workout_session with NO scheduled_days in a program whose other sessions have days: the app shows it as "Extra", outside the weekly goal.
kinevo_create_exercise
ChatGPTCreate a custom STRENGTH exercise in THIS trainer's own library (owner = the trainer), e.g. when you want to prescribe a movement that isn't in the catalog yet. Link it to muscle groups by name — existing groups (the trainer's own + Kinevo's) are matched case-insensitively; names that don't match are reported back (not created). After creating, the exercise is available to kinevo_list_exercises and the program builder. IMPORTANT: aerobic ACTIVITIES (running, walking, bike, swimming, treadmill, rowing…) are NOT library exercises — prescribe them as cardio blocks via kinevo_add_cardio_to_session (standalone cardio sessions via session_type='cardio'), which gives the student a guided timer, structured intensity (zones/RPE/pace) and weekly progression. Names that look aerobic are rejected unless confirm_strength=true.
kinevo_create_form_template
ChatGPTCreate a NEW form template (anamnese / check-in / survey / feedback) in the trainer's library from a list of structured questions. The app shows a card with the questions for the trainer to APPROVE before anything is created. Use it whenever the trainer asks for a form, questionnaire, anamnese, check-in or evaluation form — NEVER paste a form as chat text as if it were the product (chat text never reaches a student). After creation, send it with kinevo_send_form.
kinevo_create_group
ChatGPTCreate a student group — a cohort that trains the same plan (e.g. 'Maratona de São Paulo', 'Turma da manhã'). In a studio the group belongs to the ORGANIZATION and colleagues can see it. Adding students is a separate step (kinevo_add_group_members).
kinevo_create_group_stage
ChatGPTAdd a stage to the group's track. A stage is one leg of the journey (e.g. 'Base', 'Específico', 'Polimento'), optionally dated and pointing at a program template. Creating the stage does NOT write anything to the students — that is kinevo_apply_group_stage.
kinevo_create_plan
ChatGPTCreate a billing plan (a product students can subscribe to). With the Kinevo Wallet (Asaas) approved, the plan can already generate online payment links — no Stripe involved. with_online_payment=true additionally creates a legacy Stripe Product/Price when the trainer still has Stripe Connect active. Does NOT charge anyone.
kinevo_create_prescription_skill
ChatGPTCreate a named PRESCRIPTION PROTOCOL (Skill) for this trainer — his method for ONE specific case (e.g. 'Retorno pós-parto', 'Off-season de corredor'). A protocol does NOT replace his prescription style: it OVERRIDES it field by field, and every field left out is inherited from the style. Every number the trainer STATES for this protocol (reps, rest, exercises per session, weekly sets) goes into its structured field too, even when it is also written in the playbook — an unfilled field is inherited from his style and the two would contradict each other at build time. Fields he did not talk about stay out (they keep following his style). playbook is the heart of it: the method in his own words (phases, progression criteria, what to do when the student stalls) — things that never fit in numeric fields. Use this when the trainer asks to create/save a protocol, method or 'jeito de prescrever' for a case, INCLUDING when he attaches a document (PDF/spreadsheet) and asks for a protocol based on it. Volume ceilings of the build playbook always win over the protocol.
kinevo_create_program
ChatGPTCreate a new training program template. This creates an empty program structure that can then have workout sessions and exercises added to it. Optionally assign it directly to a student.
kinevo_create_program
ChatGPTCreate an EMPTY program shell, to be populated afterwards with kinevo_add_workout_session + kinevo_add_exercise_to_session. Omit student_id to create a REUSABLE TEMPLATE that appears in the trainer's Program Library (Biblioteca de Programas); pass student_id to create it already assigned to that student as a draft. TIP: to build a full library template (sessions + exercises) in a single call, prefer kinevo_create_program_template.
kinevo_create_program_template
ChatGPTCreate a COMPLETE reusable program template in the trainer's Program Library (Biblioteca de Programas) in ONE transactional call: the program plus all its workout sessions, exercises, supersets and per-set schemes. Use this — instead of orchestrating create_program + N add_session + M add_exercise — whenever you have the whole template designed up front. The template can later be assigned to any student with kinevo_assign_program (action 'assign_template'), which copies it and materializes the schedule. All exercise_id values must exist in the catalog (kinevo_list_exercises). WEEKLY PERIODIZATION: pass progression on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week.
kinevo_create_student
ChatGPTRegister a new student for this trainer. Creates the student profile with Supabase Auth account and optionally sets clinical/training preferences.
kinevo_create_student
ChatGPTRegister a new student for this trainer. Creates the student profile with Supabase Auth account and optionally sets clinical/training preferences.
kinevo_create_student_draft_program
ChatGPTCreate a COMPLETE workout program as a DRAFT assigned directly to a SPECIFIC student, in ONE transactional call: the program plus all its workout sessions, exercises, supersets and per-set schemes. The draft is INVISIBLE to the student and lands on the student's profile ("Rascunho criado pelo assistente") for the trainer to review and then ACTIVATE — or discard. Prefer this over kinevo_create_program_template (which creates a REUSABLE library template, not tied to a student) and over kinevo_create_program + N add_session (incremental, NOT transactional) whenever you've designed a program FOR THIS STUDENT. It does NOT activate the program — the trainer activates from the profile (or via kinevo_assign_program action 'activate_draft'). All exercise_id values must exist in the catalog (kinevo_list_exercises). WEEKLY PERIODIZATION: pass progression on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week.
kinevo_create_superset
ChatGPTCreate a superset (or bi-set/tri-set) inside a workout session: a group of exercises performed back-to-back with rest taken only after the group. Creates the superset container plus its child exercises in one call. Works for templates and assigned programs.
kinevo_create_superset
ChatGPTCreate a superset (or bi-set/tri-set) inside a workout session: a group of exercises performed back-to-back with rest taken only after the group. Creates the superset container plus its child exercises in one call. Works for templates and assigned programs.
kinevo_delete_program
ChatGPTPermanently DELETE (discard) a DRAFT assigned program of a student — e.g. an AI-authored draft the trainer decided not to use. Works ONLY on drafts (status='draft'); the program and its workouts are removed. This is for WORKOUT PROGRAMS, not billing: to cancel a contract/subscription use kinevo_cancel_contract instead. To END an ACTIVE program while preserving the student's training history, use kinevo_expire_program — NOT this tool (deleting an active program is not allowed here).
kinevo_delete_workout_item
ChatGPTRemove an exercise from a workout session. This permanently deletes the item (and any superset children attached to it). Use to clean up exercises when editing a session in-place.
kinevo_delete_workout_item
ChatGPTRemove an item from a workout session — an exercise, a superset/circuit (with its children), a cardio block, a note or a warmup. Permanently deletes it. Use it to REMOVE something the trainer no longer wants. To CHANGE an item that stays — including rewriting a warmup's drills or an aerobic block — use kinevo_update_workout_item (warmup_config / cardio_config / group_config): deleting and re-adding loses what the trainer wrote and reads to them as 'you deleted my block'.
kinevo_delete_workout_session
ChatGPTDelete a workout session from a program. This permanently removes the session and all its exercises (cascade). Use to clean up old sessions when editing a program in-place.
kinevo_delete_workout_session
ChatGPTDelete a workout session from a program. This permanently removes the session and all its exercises (cascade). Use to clean up old sessions when editing a program in-place.
kinevo_dismiss_insight
ChatGPTDismiss an alert/insight the trainer says is wrong or already handled. It is the TRAINER'S call: when they ask to dismiss, dismiss — do not demand evidence or re-check the data first (you may mention what you saw). reason 'not_true' = the alert does not make sense; 'resolved' = already handled outside. Use the insight id from kinevo_list_insights. It disappears from the attention panel and the same alert stays quiet for a while.
kinevo_duplicate_program
ChatGPTDuplicate an existing program in one call: copy an ASSIGNED program (any status — great for "same program for another student" or "next cycle") or a library TEMPLATE into a new STUDENT DRAFT (target='student_draft', requires student_id) or a new library TEMPLATE (target='template'). Copies sessions, schedules, exercises, supersets, per-set schemes, pre-configured substitutes and notes. The copy is created INERT (draft/template) — nothing changes for any student until the trainer activates it. Use kinevo_list_programs / kinevo_get_program to pick the source.
kinevo_expire_program
ChatGPTManually expire/deactivate an active program. The program's data is preserved but it will no longer appear as the student's current program.
kinevo_expire_program
ChatGPTManually expire/deactivate an active program. The program's data is preserved but it will no longer appear as the student's current program. Works for either of the student's active programs — the main one and the second block (a student may have strength and running running in parallel, each with its own dates).
kinevo_explain_training
ChatGPTMostra um cartão interativo confiável para EXPLICAR uma prescrição: progression (dupla progressão por repetições), volume (antes/depois de UM exercício por semana) ou sequence (bi-set/superset/circuito simples). Não grava nem envia nada. Use quando o treinador pedir explicação visual, simulação ou comparação; preencha apenas valores conhecidos ou marque example. Não use para prescrever/editar, mostrar execução real, anatomia humana ou prever resultados fisiológicos. Os cálculos são feitos pelo Kinevo.
kinevo_finalize_assessment
ChatGPTFinalize an assessment: computes the derived metrics (BMI, body-fat %, lean/fat mass, WHR) from the saved measurements using the template protocol, marks it completed, and notifies the student (inbox). This shares the results WITH THE STUDENT — confirm with the trainer before finalizing. Cannot be undone.
kinevo_find_exercise_substitutes
ChatGPTFind substitute candidates for an exercise (injury/pain, missing equipment, or preference). Returns the reference exercise plus catalog alternatives that share its movement pattern and/or muscle groups, and — when student_id is given — the student's medical restrictions. THE TOOL DOES NOT DO CLINICAL REASONING: from the candidates, YOU pick 2-3 options that avoid the limitation the trainer described (e.g. shoulder pain → prefer neutral-grip/machine variants, avoid overhead), explain why, and let the trainer choose. Then apply the swap with kinevo_update_workout_item if a program item was given.
kinevo_generate_checkout_link
ChatGPTGenerate a payment link to charge a student for a plan. Returns a URL the trainer sends to the student. This STARTS A BILLING flow. The rail is chosen automatically: if the Kinevo Wallet (Asaas) is approved, the link accepts PIX, card or boleto and follows the plan's installment setting; otherwise it falls back to the legacy Stripe checkout. Use mode='recurring' for a subscription that renews on its own (Wallet: credit card only) or mode='one_off' for a single charge for the plan period. Call WITHOUT confirm first to get a preview of exactly who will be charged and how much, then call again with confirm=true only after the trainer approved. Pick plan_id via kinevo_list_plans (only plans with checkout_ready=true work) and student_id via kinevo_list_students.
kinevo_generate_progress_report
ChatGPTGenerate a SHAREABLE progress report for a student: a public tokenized page (and story image) with the trainer's branding, meant for the student to post. Choose which sections to include (loads progression, adherence, PRs; body measurements ONLY if the trainer explicitly asked). Creates a public link — requires trainer approval (HITL card).
kinevo_get_assessments
ChatGPTRead a student's physical assessment sessions (anthropometry: weight, circumferences, skinfolds, body fat, BMI; and field tests the student executed from the Calendário, marked origin='student_execution' — for those, kinevo_get_field_tests gives the full result and the anchors). Pass session_id to get one full session with all measurements and computed metrics; otherwise lists the trainer's sessions (optionally filtered by student or status). Use for "how is the student's body composition evolving?".
kinevo_get_conversation
ChatGPTGet messages from a conversation with a specific student, ordered by most recent first.
kinevo_get_conversation
ChatGPTGet messages from a conversation with a specific student, ordered by most recent first.
kinevo_get_dashboard_summary
ChatGPTGet an overview of the trainer's account: total students, active programs, students without programs, students inactive for 7+ days, recent activity, and key metrics.
kinevo_get_dashboard_summary
ChatGPTGet an overview of the trainer's account: total students, active programs, students without programs, students inactive for 7+ days, recent activity, and key metrics.
kinevo_get_evidence
ChatGPTGet the full curated summary of one paper by paper_id, DOI or PMID. Use it to re-open a study mentioned earlier in the conversation before citing it again — citations are only valid when the study was returned by a tool in the CURRENT turn.
kinevo_get_form_responses
ChatGPTGet form/check-in responses submitted by a student. Includes pre/post-workout check-ins, anamneses, and surveys.
kinevo_get_form_responses
ChatGPTGet form/check-in responses submitted by a student. Includes pre/post-workout check-ins, anamneses, and surveys. Each answer comes back as a question/answer pair, and scale answers carry their range and direction (e.g. "1/5 (Muito baixo — nota maior é pior)"). Read the direction: a low number is not automatically bad, and a high number is not automatically good — it depends on what the question measures.
kinevo_get_form_template
ChatGPTRead a form/check-in/anamnese template's QUESTIONS (label, type, options, required). Find it by template_id, or by title (partial, case/accent-insensitive). Covers the trainer's own templates, Kinevo system templates and the studio's templates. Use it to answer 'quais perguntas tem o formulário X?' before sending or editing.
kinevo_get_group
ChatGPTRead one group in full: its members and the stages of its track (the dated sequence of program templates the cohort goes through). Read this before creating or applying a stage.
kinevo_get_nutrition_adherence
ChatGPTHow well a student is following the MEAL PLAN prescribed by their nutritionist, from the meals the student marks in the app ('Fiz', 'Fiz em parte', 'Não fiz'). Returns the rate (partial counts as half), days with a plan, days the student marked something, and per-day numbers for up to 62 days (default 14). The student's coach sees NUMBERS only; the nutritionist (or a coach the nutritionist shared the record with) also gets the student's recent notes. Use it for 'is the student following the diet?' and to cross with training (e.g. a week with low intake). It never shows the plan content to the coach.
kinevo_get_prescription_skill
ChatGPTRead this trainer's prescription protocols. With skill_name, returns that protocol in full (method text and structured fields). Without it, lists every protocol with when to use it and the start of its method. Use it to reuse a block the trainer already wrote in another protocol, to start a new protocol from an existing one, and to read a protocol before editing it.
kinevo_get_program
ChatGPTGet full details of a training program including all workout sessions and exercises with sets, reps, and loads. Works for both templates and assigned programs.
kinevo_get_program
ChatGPTGet full details of a training program including all workout sessions and exercises with sets, reps, and loads. Works for both templates and assigned programs. A session may also carry schedule_kind and dates — present ONLY when the trainer moved, cancelled or placed that session on specific calendar dates. schedule_kind: 'weekly' (repeats on scheduled_days), 'dated' (no weekday — it happens on the listed dates and does NOT repeat: a race, a 1RM test), 'free_day' (no weekday and no date — the student does it once a week, whenever). dates.moved already pairs origin and destination, so never read a move as a separate removal plus placement. NEVER 'fix' a dated session by giving it scheduled_days, and never undo a move — those dates are the trainer's deliberate plan. last_day is the LAST day the program is valid (inclusive) and next_program_starts_on is the day right after it — use these (with their weekday labels) when scheduling the next program, never started_at + weeks. An exercise with reps_unit: 'seconds' is prescribed by TIME: its reps (and every set_scheme row) are seconds — plank reps '45' = 45s. An exercise with weekly progression carries progression_origin: 'manual' (the trainer set the weeks by hand — his decision), 'generated' (weeks generated from a rule by the automatic progression; auto_progression.rule_summary says which, e.g. '+1 rep/semana, deload na S4 (padrão)') or 'generated_edited' (generated, then some weeks edited by hand — auto_progression.edited_weeks). Describe generated weeks as the rule, never as week-by-week choices of the trainer. auto_progression.base_changed = week 1 or the duration changed after generating; offer to re-apply the rule (kinevo_apply_auto_progression).
kinevo_get_revenue_summary
ChatGPTGet a financial summary: MRR (Monthly Recurring Revenue), new contracts this month, cancellations, and payment status overview.
kinevo_get_revenue_summary
ChatGPTGet a financial summary: MRR (Monthly Recurring Revenue), new contracts this month, cancellations, and payment status overview.
kinevo_get_student
ChatGPTGet the complete profile of a specific student including personal data, clinical conditions, training history, and current program. Use this when the trainer asks about a specific student's details.
kinevo_get_student
ChatGPTGet the complete profile of a specific student including personal data, clinical conditions, training history, and current program. Use this when the trainer asks about a specific student's details.
kinevo_get_student_progress
ChatGPTGet a student's training progress including workout history, adherence rate, and load progression over time. Can filter by date range and specific exercise for load tracking.
kinevo_get_student_progress
ChatGPTGet a student's training progress including workout history, adherence rate, and load progression over time. Can filter by date range and specific exercise for load tracking. With exercise_id, each exercise_progression entry carries unit: 'reps' entries have sets (weight/reps) and estimated_1rm; 'seconds' entries (timed sets, e.g. plank 45s) have NO 1RM — read best_duration_seconds / total_duration_seconds (and the *_label strings like "1min30s") to see the progression. exercise_summary gives the best mark over the period in the same unit. Timed sets record reps=0, so they add no kg volume — that is expected.
kinevo_get_weekly_adherence
ChatGPTWeekly adherence PER STUDENT for the current week (Monday → today, America/Sao_Paulo): workouts done vs. workouts expected so far (pro-rata: only the days already passed count), plus the full-week target. Use it for 'quem está em dia / quem está faltando / treinos planejados vs. concluídos'. Students behind come first.
kinevo_get_workout_checkins
ChatGPTRead a student's most recent pre/post-workout check-in answers (how they felt, soreness, energy, etc). Use to understand how training is going for a specific student. Returns the latest submissions newest-first. Read the readable field: it pairs each question with its answer and states the scale's range and direction. A low score is not automatically bad — on a fatigue or pain question the low end is the GOOD end.
kinevo_list_appointments
ChatGPTList the trainer's scheduled training sessions (agenda) within a date range, with student name, time, duration and status. Each occurrence already has reschedules/cancellations applied. Use for 'what do I have today / this week?'. recurring_appointment_id + the occurrence date are what you pass to reschedule/cancel/mark-status tools.
kinevo_list_class_slots
ChatGPTList the trainer's own classes (turmas): times opened with a set number of spots, e.g. 'Funcional, Tuesday 07:00, 6 spots'. Returns id, title, weekday (0=Sunday … 6=Saturday), start time, duration, spots (capacity) and how many students are enrolled. Use the id as appointment_group_id in kinevo_create_appointment to put a student in a class. Solo/personal accounts only; studio schedules use the studio's own published slots.
kinevo_list_conversations
ChatGPTList the trainer's conversations with students, ordered by most recent message. Shows unread count for each conversation.
kinevo_list_conversations
ChatGPTList the trainer's conversations with students, ordered by most recent message. Shows unread count for each conversation.
kinevo_list_exercises
ChatGPTSearch the exercise catalog. Returns exercises available to this trainer (system exercises + trainer's custom exercises). Filter by muscle group, equipment, or name.
kinevo_list_exercises
ChatGPTSearch the exercise catalog. Returns exercises available to this trainer (system exercises + trainer's custom exercises). Filter by muscle group, equipment, or name. When PLANNING A PROGRAM, fetch ALL the muscle groups you need in ONE call via muscle_groups (e.g. muscle_groups: ['Peito','Costas','Ombros','Quadríceps','Posterior de Coxa','Glúteo'], limit: 100) — the result comes BALANCED per group; NEVER call this tool once per group. To look up SPECIFIC exercises by name, pass ALL the names in ONE call via searches (e.g. searches: ['Stiff','Hip Thrust','Remada Curvada']) — NEVER call once per name; each extra call re-sends your whole context. Results are ordered with PRIMARY/COMPOUND movements FIRST (is_primary_movement=true, session_position='first' — e.g. squat, deadlift, row, pulldown, bench, press): use those as the MAIN lift at the start of each session, and the accessories/isolation that follow to add volume. Prefer compound staples over obscure isolation variants FOR THE WORKING SETS. For a WARMUP the opposite is true and the catalog has the groups for it: muscle_groups ['Mobilidade','Mobilidade Quadril'] for mobility drills, ['Pliometria','Potência'] for the last (integration) band, and searches ['Liberação'] for foam-roll drills; activation has no group of its own — find it by name (searches ['Ponte','Abdução de Quadril 4 Apoios','Prancha']).
kinevo_list_form_schedules
ChatGPTList the ACTIVE recurring form schedules for a given student (which forms repeat and how often, and when each is next due). Use to review or before changing a student's recurring check-ins.
kinevo_list_form_templates
ChatGPTList the form/check-in/anamnese templates this trainer can send (the trainer's own templates plus Kinevo system templates). Call this to pick a template_id before sending with kinevo_send_form. To read what students have ANSWERED, use kinevo_get_form_responses instead.
kinevo_list_groups
ChatGPTList the trainer's student groups (cohorts training the same plan). Use to find a group's id before working on it. In a studio, groups belong to the organization and colleagues see each other's.
kinevo_list_insights
ChatGPTList the AI-generated insights/alerts for this trainer (e.g. student at churn risk, adherence drop, billing attention). Good for "any important alerts today?". By default returns active (non-dismissed, non-expired) insights, highest priority first.
kinevo_list_leads
ChatGPTList this trainer's CRM leads (prospective students captured via landing pages / capture forms). Shows contact info, goal, level and status. Use for "who are my new leads?" or to follow up.
kinevo_list_plans
ChatGPTList this trainer's billing plans (the products a student can be charged for). Use to pick a plan_id before generating a payment link with kinevo_generate_checkout_link. checkout_ready is true when the trainer can actually charge for that plan — either the Kinevo Wallet (Asaas: PIX, card, boleto) is approved, or the plan has a legacy Stripe price. payment_rail says which one will be used.
kinevo_list_programs
ChatGPTList training programs created by this trainer. Can filter by student (to see their program history) or by status. Returns both program templates and assigned programs.
kinevo_list_programs
ChatGPTList training programs created by this trainer. Can filter by student (to see their program history) or by status. Returns both program templates and assigned programs.
kinevo_list_students
ChatGPTList the trainer's students with optional filters. Returns active students by default. Use this to find students by name, check who is active/inactive, or get an overview of all students.
kinevo_list_students
ChatGPTList the trainer's students with optional filters. Without status, returns students of every status (active, inactive, pending); trial prospects only with include_prospects. Use this to find students by name, check who is active/inactive, or get an overview of all students.
kinevo_list_subscriptions
ChatGPTList student contracts/subscriptions managed by this trainer. Shows payment status, plan, amount, and next billing date.
kinevo_list_subscriptions
ChatGPTList student contracts/subscriptions managed by this trainer. Shows payment status, plan, amount, and next billing date.
kinevo_list_training_methods
ChatGPTList the advanced prescription capabilities available when building or editing workouts: training-method presets (pyramid, drop-set, cluster, 5x5, top+backoff), the per-set scheme fields, the valid set types, and how supersets work. Call this before prescribing advanced methods so you pass the right method_key, set_scheme, and rounds to kinevo_add_exercise_to_session / kinevo_update_workout_item.
kinevo_list_training_methods
ChatGPTList the advanced prescription capabilities available when building or editing workouts: training-method presets (pyramid, drop-set, cluster, 5x5, top+backoff), the per-set scheme fields, the valid set types, how supersets work, plus the AEROBIC toolkit — named interval protocols (Tabata, HIIT 30/30, 4×4 norueguês…) and the HR zone model (Z1–Z5) used by kinevo_add_cardio_to_session. Call this before prescribing advanced methods so you pass the right method_key/set_scheme/rounds or protocol/zone.
kinevo_mark_appointment_status
ChatGPTMark a session occurrence as completed (the session happened) or no_show (student missed it). Use this to keep attendance accurate. This does not notify the student.
kinevo_mark_form_responses_read
ChatGPTMark form/check-in responses as READ (reviewed) without writing feedback — it only clears the trainer's pending list; the student is NOT notified. Pass submission_ids (the ids from kinevo_get_form_responses) or all_pending=true to clear every pending response (optionally only one student's).
kinevo_mark_payment_as_paid
ChatGPTRecord a MANUAL payment on a contract: marks it active, records the revenue (financial_transactions) and renews the period for recurring plans. Use when a student paid you outside the app (cash, PIX, etc). Call WITHOUT confirm first to preview the exact amount; call again with confirm=true only after the trainer approved. Beware: calling twice records the income twice.
kinevo_match_exercises
ChatGPTIMPORTING a program the trainer already has (attached file, image or pasted text): match ALL exercise names of the source in ONE call, written exactly as in the source. Each name comes back as 'matched' (use its exercise_id), 'review' (no clear match: use the best candidate's exercise_id — the trainer confirms it on the preview card) or 'new' (nothing in the catalog: send the item with new_exercise: { name } instead of exercise_id; it is created only when the program is saved). Use this INSTEAD of kinevo_list_exercises when importing. Not for designing new programs.
kinevo_merge_exercises
ChatGPTMERGE duplicate exercises of THIS trainer's library into ONE that stays (e.g. the same movement imported twice, in Portuguese and English: 'Step Up DB' + 'Dumbbell Step-Up' → 'Subida no step com halteres'). Everything that points to the merged ones — prescriptions in every program (including a studio colleague's students), templates, the students' logged sets (history becomes one), comments, substitutes, warm-up drills, the video when the kept one has none — moves to the kept exercise, and the merged ones are DELETED. Irreversible. Merged (source) exercises must be the trainer's own; the kept one (target) is the trainer's own or a Kinevo catalog exercise. Get ids with kinevo_list_exercises. Only merge what is truly the SAME movement (same implement, laterality and variation) — when unsure, ask the trainer. Without confirm=true it only returns the preview (what moves).
kinevo_move_workout_occurrence
ChatGPTMove ONE occurrence of a session from one day to another — 'this week the long run goes to Monday'. The weekly recurrence is untouched: the following weeks stay as they were. The origin day does not become a missed workout, and the week's target does not change (one date leaves, another arrives). Both days must be in the same program.
kinevo_ping
ChatGPTTest the connection to Kinevo. Returns trainer name and account status.
kinevo_ping
ChatGPTTest the connection to Kinevo. Returns trainer name and account status.
kinevo_place_workout_on_date
ChatGPTPut an existing workout session on a specific day of the student's calendar. THE MODE IS THE WHOLE POINT: mode='date' places it ONLY on that date (a one-off — the weekly recurrence is untouched), while mode='weekly' writes that weekday into the session's recurrence, exactly like the scheduled_days chip in the builder, so it repeats every week from then on. Use 'date' for a one-off (a race, a test, a session pulled forward because of a trip) and 'weekly' when the trainer is changing the routine itself. Placing a date OUTSIDE the program's window is allowed — the occurrence still counts; the trainer can extend the program afterwards with kinevo_update_program.
kinevo_reactivate_student
ChatGPTReactivate a previously archived student (the reverse of kinevo_archive_student). Without student_id it LISTS the archived students this trainer can reach, including whether each one can be reactivated (a student who meanwhile joined another trainer cannot). In a STUDIO the list is the organization's: any member reactivates any archived student of the studio, whoever archived them. Solo trainers see the ones they archived themselves. With student_id but confirm=false it returns a PREVIEW; with confirm=true it relinks the student to this trainer, notifies them, and their full history is available again. Canceled contracts and appointment routines do NOT come back automatically — recreate them if needed. Reactivating counts toward the plan's (or the studio tier's) student cap, like creating a student.
kinevo_remove_workout_from_date
ChatGPTTake a session OFF one specific day, without touching the rest of the plan — 'this Tuesday there is no run'. The weekly recurrence stays intact: only that date stops expecting the session, and it does NOT count as a missed workout for the student. To undo a previous removal, call kinevo_place_workout_on_date with mode='date' on the same day.
kinevo_reschedule_appointment
ChatGPTReschedule a scheduled session occurrence to a new date/time. scope='only_this' moves just that one occurrence; scope='this_and_future' ends the current routine and starts a new one from the new date (use when the recurring slot itself changed). The student is notified.
kinevo_resend_student_access
ChatGPTGenerate a fresh single-use access link for an EXISTING student of this trainer, so the trainer can send it to them (the student then sets their own password). Use when the student never got in, lost the password or the first link expired. Kinevo does NOT email the student — the trainer sends the link. Call WITHOUT confirm first to preview which student it is for; call again with confirm=true only after the trainer approved.
kinevo_schedule_form
ChatGPTSet up a RECURRING form/check-in for one or more students: the form is sent automatically on each due date (the student is notified every time). Use for ongoing weekly check-ins, monthly or QUARTERLY reassessments, etc. For a ONE-OFF send, use kinevo_send_form instead. Pick template_id via kinevo_list_form_templates and student ids via kinevo_list_students. Confirm the cadence with the trainer before scheduling. Cadence: use frequency for the four common ones, or interval_unit + interval_count for anything else — bimestral = month/2, trimestral = month/3, semestral = month/6, anual = month/12.
kinevo_search_evidence
ChatGPTSearch scientific evidence (PubMed/Europe PMC) for training-related questions: training volume, frequency, load, periodization, aerobic prescription, special populations, pain/injury, recovery, supplements, adherence. Answers from a curated corpus of 49 topics; for anything outside it, falls back to a live PubMed search when you provide search_terms_en. Returns papers with a PT-BR summary (finding, population, dose, practical takeaway, strength of evidence) and a ready-to-paste markdown citation field. ONLY cite studies returned by this tool. Use it when the trainer asks what the science says, asks you to justify a prescription choice, or questions a recommendation — not for operational tasks.
kinevo_send_form
ChatGPTSend a form/check-in/anamnese to one or more students. The form lands in each student's app inbox as a pending request and triggers a push notification. Pick template_id via kinevo_list_form_templates and student ids via kinevo_list_students. Students who already have this same form pending are skipped (no duplicate). Use for weekly check-ins, onboarding anamnese, periodic reassessments, etc.
kinevo_send_message
ChatGPTSend a text message to a student. The message appears in the student's Kinevo app inbox.
kinevo_send_message
ChatGPTSend a text message to a student. The message appears in the student's Kinevo app inbox.
kinevo_send_message_batch
ChatGPTSend the SAME text message to SEVERAL students at once (e.g. "avisa todo mundo que amanhã não tem treino", all inactive students, a group). ONE aggregated confirmation instead of N — prefer this over calling kinevo_send_message repeatedly. For a single student use kinevo_send_message. Resolve the ids first via kinevo_list_students; every id must belong to this trainer.
kinevo_set_student_anchors
ChatGPTWrite the student's ZONE ANCHORS on their profile: max heart rate (bpm) and/or threshold pace (min:ss per km). They are what turns "Zona 2" into this student's bpm and min/km range in prescriptions, in the app and on the watch; workouts already scheduled get the new range too. Use it after an assessment that measured them (pass assessment_session_id, it goes to the anchor history) or when the trainer gives the value ('a FC máxima dele é 185'). Without confirm=true it returns a PREVIEW (current vs new) and changes nothing — show it and only confirm after the trainer's yes. For a test scheduled on the Calendário use kinevo_apply_field_test_anchors instead.
kinevo_update_class_slot
ChatGPTChange a class (turma): name, number of spots or note. Weekday, time and duration can only change while the class has NO student enrolled (to move a class with students, open a new one and move each student). Spots can't go below the number already enrolled. Only the fields you pass change.
kinevo_update_form_template
ChatGPTEdit a form template that belongs to THIS trainer: title, description, category, or the questions. The app shows the same approval card as creation, with the resulting question list. Pass questions only when changing them — it REPLACES the whole set, so send the full list including the ones you are keeping. Answers already submitted are NOT affected (each submission keeps a snapshot of the form the student saw). Pick template_id via kinevo_list_form_templates; system templates (not owned by the trainer) cannot be edited.
kinevo_update_group_stage
ChatGPTEdit a stage of the track in place: rename it, point it at another template, or move its window. Only the fields you pass change. Editing a stage does NOT rewrite programs already applied to students — those are their own copies.
kinevo_update_lead_status
ChatGPTUpdate a lead's status in the CRM pipeline (new → read → contacted → converted/archived). Use to mark a lead as contacted or archive it. To actually turn a lead into a student account, that is done in the app (not via this tool).
kinevo_update_plan
ChatGPTUpdate an existing plan. Only the fields you pass are changed (the rest keep their current values). Changing price/interval on a plan with online payment archives the old Stripe price and creates a new one — existing subscriptions keep the old price. Does NOT charge anyone.
kinevo_update_prescription_skill
ChatGPTEdit an EXISTING prescription protocol of this trainer — rename it, change when to use it, rewrite or extend its playbook, or change its structured fields. Use this (never kinevo_create_prescription_skill again) whenever the trainer adds details to, corrects or renames a protocol that already exists, INCLUDING one created earlier in this same conversation. Identify it by skill_name (its current name). Only the fields you send change: playbook REPLACES the whole method text, so send it complete (start from the current text in <<METODO_DA_SKILL>> or from the card you proposed earlier); if you do not have the current text, use playbook_append to add a paragraph instead. Structured fields you send replace those fields; clear_fields makes a field go back to following his style.
kinevo_update_program
ChatGPTUpdate a program's metadata in-place: name, description or duration_weeks. Works for assigned programs (any status) and library templates — use it instead of recreating the program. Typical use: extending duration_weeks so a cardio block's weekly progression fits (the progression's highest week must be ≤ duration_weeks).
kinevo_update_student
ChatGPTUpdate an existing student's profile data such as name, phone, objective, modality, notes, or training level.
kinevo_update_student
ChatGPTUpdate an existing student's profile data such as name, phone, objective, modality, notes, or training level. To change the student's STATUS use status_name (the trainer's own statuses such as 'Férias' or 'Lesionado', or 'Ativo' / 'Pausado') and, for a return date, status_until — e.g. 'coloca a Ana de férias até dia 20' = status_name 'Férias' + status_until.
kinevo_update_workout_item
ChatGPTEdit an exercise inside a workout session in-place: change sets, reps, rest, notes, function, training method, position, or swap the exercise itself. Also supports advanced per-set prescription via set_scheme (replaces the whole per-set scheme). Only the fields you pass are changed.
kinevo_update_workout_item
ChatGPTEdit an item inside a workout session in-place: change sets, reps, rest, notes, function, training method, position, or swap the exercise itself. Also supports advanced per-set prescription via set_scheme (replaces the whole per-set scheme). For cardio blocks, pass cardio_config to replace the block's aerobic prescription (mode/equipment/duration/intervals/intensity); for WARMUP blocks, pass warmup_config to rewrite the block (drills, bands, targets, title) — ADJUSTING a warmup is an edit, never a delete followed by a new block. Only the fields you pass are changed. WEEKLY PERIODIZATION: pass progression on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week. Pass progression: [] to remove the weekly periodization of the exercise entirely.
kinevo_update_workout_session
ChatGPTRename, reorder, or reschedule an existing workout session in a program. Use this to edit a session in-place without recreating the program — including setting which weekdays the session falls on (scheduled_days).
kinevo_update_workout_session
ChatGPTRename, reorder, or reschedule an existing workout session in a program. Use this to edit a session in-place without recreating the program — including setting which weekdays the session falls on (scheduled_days) and converting its type (session_type 'strength' ↔ 'cardio'; converting to 'cardio' requires the session to have no strength exercises).
