Skip to main content
Glama

Server Details

The workout tracker your AI can edit: build programs, swap exercises and read your logged sets.

Ownership verified
Status
Healthy
Uptime
50.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

A3.7/5.0

Scored across 25 tools

Disambiguation4/5

Most tools map to a distinct resource/action, and the read tools (get_athlete_context, get_logs, get_today, list_exercises) are clearly separated. There is some potential confusion among similarly prefixed program tools, such as set_program_day vs set_program_week, set_program_ladder vs set_ladder_level, and set_rest_day vs rest events in upsert_events, but the descriptions give useful boundaries.

Naming Consistency4/5

The surface is mostly consistent snake_case verb_noun naming with clear prefixes: get_, list_, add_, update_, set_, remove_, and upsert_. The main deviation is whoami, which does not follow the verb_noun pattern, and a few long compound names, but the overall convention is predictable.

Tool Count3/5

At 25 tools, the server is on the heavy side for an MCP tool set, even though the training-coach domain is broad. Many tools cover legitimate distinct resources, but some program-management CRUD could likely be consolidated, making the count borderline rather than clearly well-scoped.

Completeness4/5

Coverage is strong across reading athlete state/logs/today/exercises, managing program days/weeks/ladders/goals/rules, writing sessions and rest days, handling calendar events, and exercise guides/videos. Minor gaps remain, such as no delete_exercise or explicit session-cancel tool, and events can only be cancelled rather than deleted, but most workflows have workarounds.

Publisher details

Operator
Nextset · Publisher source
Vendor relationship
First-party
Trust center
Not available
Restrictions
Private beta: access is by invitation and requires a Nextset account (sign in with OAuth). Free during the beta. · Publisher source

Available Tools

25 tools
add_exerciseAdd an exerciseAInspect

Adds an exercise to the catalog when the athlete wants one that list_exercises doesn't have. Write the name in sentence case, like the catalog's ("Single-leg calf raise", "KB sumo deadlift"): a capital on the first word only, plus abbreviations and people's names. The id is made from the name and must not clash with an existing one. kind is required: back (shown as Foundation), strength or mobility (or other), the block kind it goes in; set_today_session only accepts it in a block of that kind. For a mobility exercise also give style (dynamic, static or release; see list_exercises). Give sides when it is clear: together (both sides at once) or each (one side per set); start.bothSides must match it, and so must every later prescription. painAreas must name at least one body area it stresses. start is required: a conservative first-time prescription to begin from. It must stay within at most 3 sets, 15 reps or 120 s per set, at least 30 s rest, and weightKg only for a loaded exercise, at most 16 kg; anything above is rejected with every problem listed. Alternatives must be ids from list_exercises. guide is required: the how-to the athlete reads before trying it, written for someone who has never seen the exercise: setup (equipment and starting position), steps (2–6, one action each, in order), feel (where they should feel it) and avoid (the one common mistake). Plain words, no medical claims. Also give a one-line instructions for the set screen. videoUrl is optional (https); the app offers a video search when there is none. The exercise is saved as not yet reviewed by the athlete; once added, its id works in set_today_session.

Inputs: kind (required), name (required), start (required), loaded (required), +8 more.

get_athlete_contextGet athlete contextA
Read-onlyIdempotent
Inspect

Returns the athlete's current training state, recent history and program. Takes no input.

Returned data:

  • Date: today (always the athlete's local date, not UTC) and timeZone, the athlete's time zone.

  • Program: name, coachBrief (what it's for), the body areas it tracks, trackPain (false: the app doesn't ask for pain levels) and custom (set when the athlete is on their own custom program). customPrograms lists their saved programs.

  • Schedule: schedule is the week: each weekday's day id and name, with parts (the part labels) on a day that repeats as a split.

  • Rules: programRules belong to the program, athleteRules to the athlete; rules combines them.

  • Profile: the athlete's profile. profile.intake, when present, holds their setup answers (days a week, session length, goal, equipment, what hurts).

  • Events: calendar events from a week ago onward.

  • Ladders: each ladder's level (0-based, here and in every tool), prescription, clean sessions so far and the usual number before stepping up, the baseline (the last prescription completed in full at that level, else the level's own) and lastChange (who moved it last; lastChange.by = athlete means the athlete changed the level themselves in the app).

  • Sessions: sessions from the last 14 days and any planned ahead, and a per-day summary of logged sets.

  • Feedback: session feedback (effort, note) and symptoms: the 0–10 level the athlete gave for each tracked body area when they finished a session.

  • skippedSets: by exercise, the sets passed with Skip exercise (it skips every set of the exercise not yet done).

  • exerciseNotes: what the athlete wrote about one exercise during the workout ("squats felt hard", "I can only do 20").

  • correctedSets (per summary): ladder and goal sets the athlete corrected at Finish, where they may fix a set the player got wrong (a hold timer stops at the target, so a longer hold is only recorded this way). Logs and summaries already show the corrected values; get_logs keeps the player's own number on each corrected set as loggedValue.

  • exerciseVideos: demo videos chosen for an exercise, by the athlete in the app (setBy athlete) or with set_exercise_video (setBy coach). The app plays them instead of the exercise's own video. Cleared choices aren't listed.

How the app behaves:

  • The app does not adjust anything for pain, rules, events, load or exercise notes: it plays each session exactly as written.

  • There is no pain input during a workout. A skipped set or a workout ended early (status abandoned, or sets with no log) is the sign something was avoided.

Inputs: no named parameters.

get_logsGet training logsA
Read-onlyIdempotent
Inspect

Returns raw set logs, session feedback, skipped sets and exercise notes (the athlete's words about one exercise, written mid-workout) between two dates (YYYY-MM-DD, inclusive, at most 31 days, to not before from). It has more detail than the summary in get_athlete_context: individual sets, and older stretches of training. A set the athlete corrected at Finish shows their number as value and the player's as loggedValue.

Inputs: to (required), from (required).

get_todayGet a day's sessionA
Read-onlyIdempotent
Inspect

Returns a day as the phone's Today screen will show it: the coach session if one is stored, otherwise the program day at the current ladder levels, or a rest day. Nothing is adjusted. date defaults to today in the athlete's time zone. A day that has started or finished is returned as stored. parts lists the day's sessions (one on an unsplit day; a split day has 2–3, each with its label, and a started or finished part is returned as stored while the others are still planned). plan is the part in progress, else the first unfinished one, else the last; status is in_progress if any part is, completed once every part has ended, otherwise planned. It shows what the athlete has planned, before or after a write.

Inputs: date.

list_exercisesList exercisesA
Read-onlyIdempotent
Inspect

Returns the exercise catalog: id, name, kind (the block kind it goes in: back (shown to the athlete as Foundation), strength or mobility; an older exercise without one can only go in an other block), equipment, whether it's loaded, the body areas it stresses, its no-kit and gentle alternatives (suggestions for you; the app never swaps), whether the athlete has reviewed it, and its conservative start prescription if any. A mobility exercise also has style: dynamic (moving through range, good before training), static (a held stretch, good after training or at the end of the day) or release (rolling; the library's roller exercises need a foam roller). An exercise you added earlier may have no style. sides says how it uses the two sides: together (both at once, e.g. a both-arms raise; prescribe bothSides: false) or each (one side per set; prescribe bothSides: true). Writes that contradict it are rejected. No sides means either works (movements that alternate within a set, or an exercise whose ladder levels change it). hasGuide says whether the athlete can read a how-to for it, hasVideo whether the exercise has its own demo video, and hasOwnVideo whether a demo was chosen for this athlete (set_exercise_video), which the app plays instead. library: true marks a built-in exercise whose guide and video you can't change; update_exercise is for library: false ones, the exercises you added, and can add a missing guide to one of those. Sessions must use these ids; add_exercise adds an exercise that isn't listed.

Inputs: no named parameters.

remove_athlete_ruleRemove one of the athlete's own rulesA
DestructiveIdempotent
Inspect

Removes one of the athlete's own rules (by id). Never changes the program.

Inputs: id (required).

remove_program_dayRemove a program dayA
DestructiveIdempotent
Inspect

Removes a day from the athlete's program; its weekdays become rest. The week must keep a training day. Forks a preset first (see set_program_day).

Inputs: dayId (required), programName.

remove_program_goalRemove a program goalB
DestructiveIdempotent
Inspect

Removes a goal from the athlete's custom program. Forks a preset first.

Inputs: id (required).

remove_program_ladderRemove a program ladderB
DestructiveIdempotent
Inspect

Removes a ladder from the athlete's custom program. Its progress is kept and comes back if the ladder does. Forks a preset first.

Inputs: exerciseId (required).

remove_program_ruleRemove a program ruleB
DestructiveIdempotent
Inspect

Removes one of the custom program's own rules. Forks a preset first.

Inputs: id (required).

set_athlete_ruleSet one of the athlete's own rulesA
DestructiveIdempotent
Inspect

Adds or replaces one of the athlete's OWN rules, which apply on every program (e.g. no strength the day before a match). Never changes the program. The app shows the rule to the athlete and does not apply it. check is still required and is stored, but nothing reads it.

Inputs: rule (required).

set_exercise_videoChoose the athlete's demo video for an exerciseA
DestructiveIdempotent
Inspect

Chooses the demo video the app plays for one exercise, for this athlete only. Works on any exercise in list_exercises, library ones included: it changes the athlete's choice, not the exercise. url is a YouTube video link (youtube.com/watch?v=…, youtube.com/shorts/…, youtu.be/…), stored in its plain form; other sites are refused, since the app plays the video in its own player. null clears the choice, and the app goes back to the exercise's own video or offers a search. reason is kept in the audit log. The phone gets it on its next sync. The newest choice wins, so a video the athlete picks later replaces this one, and this one replaces theirs.

Inputs: url (required), reason (required), exerciseId (required).

set_ladder_levelMove a ladder levelA
DestructiveIdempotent
Inspect

Moves one ladder of the athlete's current program up or down by one level (to is the 0-based level index, as in get_athlete_context). The server does not gate the move; cleanCount and cleanNeeded are returned. reason (short) is kept in the audit log. The server then re-checks planned coach sessions from today at the new level: revalidated lists days it updated and withdrawn days that no longer pass.

Inputs: to (required), reason (required), exerciseId (required).

set_program_dayChange a program day for every weekA
DestructiveIdempotent
Inspect

Changes one day of the athlete's program for EVERY future week (for one date only, use set_today_session). dayId must be an existing day (see schedule in get_athlete_context) unless you pass create: true to add a new day. weekdays is optional: omitted, an existing day keeps its weekdays and a new day starts unscheduled; given, it is the day's full placement and weekdays it leaves become rest. Blocks use exercise ids from list_exercises; an exercise with a ladder leaves its prescription out. A day is at most 90 minutes. If the athlete is on a preset (Strong Back, Strong Knees), this first saves their own custom copy (default name " (custom)", or programName) and moves them onto it; their schedule and history stay. A rejected call changes nothing. Returns the program and a preview of the next date that plays the day. A coach session already written for a date still wins on that date. To make a day repeat as a split, send parts (2–3 labels, e.g. Morning, Afternoon) and a part (1-based) on every block, in part order; the whole day stays within 90 minutes and each exercise once. Omitting parts while blocks carry part is refused (send parts to keep a split, or drop part from every block to merge it). On the empty "Build with your coach" program the other program tools are refused until a day is scheduled with this tool (create: true and weekdays). For a superset or circuit, put its exercises in their own block with rounds: true: the app plays set 1 of each in order, then set 2 of each. Rest after a set is that item's restSeconds, so give every item but the last 0 (or a short walk-over) and the last the rest between rounds. Set counts may differ; an item with fewer sets drops out of the later rounds. In a round where the last item has dropped out, the rest after the round is the rest of the last item still playing. A rounds block needs 2 or more exercises; with one it is played as straight sets.

Inputs: name (required), dayId (required), blocks (required), parts, +3 more.

set_program_goalSet a program goalB
DestructiveIdempotent
Inspect

Adds or replaces (by id) a measurable goal on the athlete's program. Forks a preset first.

Inputs: goal (required), programName.

set_program_infoUpdate program details and pain trackingA
DestructiveIdempotent
Inspect

Changes the athlete's program details: name, coachBrief, equipmentNote, trackingAreas (the body areas the app asks about after a session) and trackPainDefault (whether it asks about pain). Only the fields given change; the rest stay as they are. At least one field is required.

  • On a preset (Strong Back, Strong Knees) this first saves the athlete's own custom copy and moves them onto it: under name if given (a name already taken gets a number, e.g. "Tennis season 2"), else " (custom)".

  • The empty "Build with your coach" program has no days: this tool is refused until a day is added with set_program_day.

  • trackPainDefault is the program's default; the athlete's own pain-tracking setting still wins.

Inputs: name, coachBrief, equipmentNote, trackingAreas, +1 more.

set_program_ladderSet a program ladderB
DestructiveIdempotent
Inspect

Adds or replaces the ladder for an exercise on the athlete's program. Progress on that exercise is kept (clamped to the new number of levels); a new ladder starts at level 0 today. Forks a preset first.

Inputs: levels (required), exerciseId (required), cleanSessionsToStepUp (required), programName.

set_program_ruleSet a program ruleA
DestructiveIdempotent
Inspect

Adds or replaces a rule that belongs to this program (it doesn't follow the athlete to another program). Rules about the athlete (e.g. their tennis) are set with set_athlete_rule. Forks a preset first. The app shows the rule to the athlete and does not apply it. check is still required and is stored, but nothing reads it.

Inputs: rule (required), programName.

set_program_weekSet the program's weekly scheduleB
DestructiveIdempotent
Inspect

Sets the whole weekly schedule: each weekday is a day id of the program or "rest", with at least one training day. Forks a preset first.

Inputs: week (required), programName.

set_rest_daySet a rest dayA
Destructive
Inspect

Makes one or more days rest days, e.g. for illness, poor sleep or a symptom flare. A rest day replaces the program day and any coach session written for it. Returns the stored rest event and the locked days.

  • Locked days: days that have already started or finished stay as they are and come back in locked (a locked part 2 or 3 of a split day also has part and partLabel).

  • set_today_session refuses a date that is a rest day until the rest event is cancelled.

  • Undo: cancel the returned event with upsert_events (same id, kind, title and dates, status "cancelled"). The app has no event list, so the athlete can't cancel it in the app.

Inputs: date (required), reason (required), end.

set_today_sessionSet today's sessionA
Destructive
Inspect

Writes the session the athlete will do today or tomorrow (date must be one of those, in the athlete's time zone). Give blocks (kind back (shown as Foundation), strength, mobility or other) of items, each an exercise id from list_exercises with a prescription (method reps, hold or time; sets; bothSides; restSeconds; optional weightKg and cue). bothSides plays each set Left then Right; it must match the exercise's sides in list_exercises (together → false, each → true), or the write is rejected. Each exercise has a kind; put it in a block of that kind (an exercise without a kind goes in an other block). timeBudgetMinutes is optional: how long the athlete has. coachNote is shown to the athlete on Today. The server owns the session's id, revision, status, change list and time estimate and fills them in. The prescription is stored as written: the server does not apply the athlete's rules, cap load or adjust for pain. An item above its ladder's current level is set to that level and listed in changes; preview is what Today will show. A session that has started, finished or been abandoned can't be replaced. A rejected write returns every reason. To split the day, send parts instead of blocks: 2–3 parts with a label each (e.g. Morning, Afternoon) and their own blocks (coachNote and timeBudgetMinutes go on each part, not the top level); the whole day stays within 90 minutes and each exercise once. Started parts are kept. Sending blocks to a split day merges it back into one session (not allowed once a later part has started); a day whose one session has started can't be split. parts in the result says which parts were written, kept and withdrawn. For a superset or circuit, put its exercises in their own block with rounds: true: the app plays set 1 of each in order, then set 2 of each. Rest after a set is that item's restSeconds, so give every item but the last 0 (or a short walk-over) and the last the rest between rounds. Set counts may differ; an item with fewer sets drops out of the later rounds. In a round where the last item has dropped out, the rest after the round is the rest of the last item still playing. A rounds block needs 2 or more exercises; with one it is played as straight sets.

Inputs: date (required), parts, blocks, coachNote, +1 more.

update_exerciseFix an exercise's guide, video or sidesA
DestructiveIdempotent
Inspect

Changes the how-to of an exercise you added: guide (setup, 2–6 steps, feel, avoid), the one-line instructions shown on the set screen, and videoUrl (an https link; null removes it). Give only what should change. It fixes a guide the athlete finds unclear or a video that is wrong or broken, and adds guides to exercises added before guides existed (list_exercises shows hasGuide: false). It also sets sides (together or each; see list_exercises) on one added without it; its start's bothSides must match. It can't change a library exercise, and it changes nothing else about the exercise. A different demo for one athlete, on any exercise including library ones, is set with set_exercise_video.

Inputs: id (required), guide, sides, videoUrl, +1 more.

update_profileUpdate the athlete profileA
Destructive
Inspect

Updates the athlete's profile: summary and goals replace what's there, addCoachNote appends one note to your running coach notes (for things worth keeping across chats, such as age, height and weight if the athlete shared them). Injuries and the setup answers (profile.intake) can't be changed from here; only the athlete can change them. Rules have their own tools (set_athlete_rule, set_program_rule).

Inputs: goals, summary, addCoachNote.

upsert_eventsAdd or update eventsA
Destructive
Inspect

Adds or updates up to 20 calendar events the athlete tells you about (match, tournament, coach_session, travel, rest, other; set_rest_day also makes rest events; dates YYYY-MM-DD, end inclusive). Omit id for a new event (the server makes the id); pass the id you got back to change or cancel one of your own (status "cancelled"). An id that doesn't exist is skipped. Events are never deleted. You can't change events the athlete created, and you can't set a cancelled event back to active; if it's back on, add it again as a new event. You can still edit a cancelled event's title or dates if you leave status out. Those come back in skipped with the reason. The app only acts on a rest event (the day becomes a rest day). Every other event is stored as context and changes no session.

Inputs: events (required).

whoamiWho am IA
Read-onlyIdempotent
Inspect

Returns the Nextset user id this connection is signed in as, and whether that account is allowed in Nextset. It answers which account the assistant is connected to, and why other tools may say the account isn't allowed.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A comprehensive AI-powered fitness tracking application that enables AI tools to interact intelligently with user fitness data, providing personalized workout plans, nutrition tracking, and progress analysis through natural language.
      15
      MIT
    • A
      license
      B
      quality
      B
      maintenance
      Provides deterministic sports-science calculators for Hyrox pacing/splits, 1RM and RPE-based working loads, Karvonen Zone 2 heart rate, 17-muscle weekly volume audits, and hybrid interference checks, so AI agents stop improvising exercise math. An optional OAuth-secured ledger also lets agents read profiles, review sessions, and log or plan workouts.
      12
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Connects AI assistants directly to Hevy workout data, enabling analysis of training volume, strength progression tracking, and web searches for fitness research.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to plan, build, and log calisthenics workouts in a user's own account, including searching exercises, managing custom workouts and plans, reading progress and coaching data, and logging completed sessions. Account mutations require explicit confirmation, and workouts can be displayed as interactive cards in the chat.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources