AgentRunCoach

Advance the athlete's guided onboarding one step. Call with no arguments to learn where onboarding stands (it starts one if needed): the result names the current step, what ARC already knows, and either a question to relay to the athlete or the tools that do this step's work. To answer a question, call again with request_id and expected_version exactly as the question carried them, plus values keyed by the question's field keys. ARC decides the order of steps from the athlete's records — a step already satisfied elsewhere is passed, and an active plan ends onboarding — so never re-ask what the result says is known. Use this instead of running an interview of your own whenever a session-start result says onboarding is in progress.

continue_onboarding

Plan-vs-actual snapshot for one calendar date. Returns the planned workout(s) for that day, any cached activities that started on the same date, and a completion entry per planned workout. Read completion, not note, to say what is finished: each entry carries the workout id and a status of completed (an activity fulfilled it, with the activity ids), completed_marked (the athlete marked it complete without a recorded activity — no measured actuals back it), missed, upcoming (today and the future are never missed), or rest. Sessions on one day finish independently, so a day can hold both a completed and a missed workout; note is a derived human line that reads like '1 of 2 completed — CG Core completed; easy 5 mi missed' on such a day, never a whole-day verdict. Includes prior coach feedback notes.

get_day_review

PERMANENTLY delete one of the athlete's Coach Assessments. Use it only when the athlete asks — typically because it turned out to be wrong, e.g. built on a duplicate run. It does not come back and no copy is kept. Never use it to update an assessment: a changed verdict is a new save_coach_assessment beside the old one. Say which assessment you are about to delete before you do it.

delete_coach_assessment

PERMANENTLY remove one of the athlete's own saved workouts from their library. Use it when they say a saved session is junk, a duplicate, or something they will never do again — the undo for save_workout_pattern. This does not come back. If they only want it out of the way, or sound at all unsure, set status 'retired' with save_workout_pattern instead: that hides it from browse and from new placements and can be undone by setting the status back. Say which one you are about to do before you do it. Reaches the athlete's OWN library only. ARC's shared workouts are read-only to them and are refused here — retiring one of those is an admin action in the app. Sessions already on the plan are untouched: placing a workout copies its steps onto the day, so the day keeps everything it had. Nothing about the athlete's history or their plan changes.

delete_workout_pattern

Soft-delete an activity (hide from listings; recoverable later).

delete_activity

Delete one planned workout from the Training Plan by id — the undo for author_planned_workout, and the way to drop a template day the athlete isn't doing. The week's mileage is recomputed. Does not delete any completed Activity that matched it; a workout already pushed to the athlete's watch is not un-scheduled there.

delete_planned_workout

Remove a race from the athlete's list, e.g. a duplicate; an upcoming one leaves the plan too. The goal race cannot be deleted; change the Training Focus instead. This is a soft-delete — the record is hidden and will no longer appear in list_races or race history, but is not permanently erased. Do NOT use this to edit a race — use patch_race for that. Requires a race_id from list_races. Destructive from the athlete's perspective.

delete_race

Mark or unmark one of the athlete's workouts as a favorite. Favorites rank first everywhere sessions are listed or offered, so this is how the athlete tells ARC which sessions they actually want to see again — set it when they say a session went well or ask for more like it.

set_workout_pattern_favorite

Generate a fresh plan from the active Training Focus and the athlete's saved Plan Preferences (which pick the library template and knobs), and persist it as the active plan. Requires a Run Fitness score on the Athlete Profile and saved Plan Preferences; if either is missing the tool returns an actionable error. The schedule is anchored to the Monday of start_date's week and schedules nothing before start_date itself; omit start_date to begin the upcoming Monday. A past start_date is treated as today. The plan is returned tiered like get_plan: every week as a spine row, workouts only for the week containing today and the next (clamped to the block), current_week_id named.

generate_plan

Read one saved Coach Assessment in full: the summary verdict, the report behind it, the evidence as the coach reported it, the Training Focus it was measured against (null means none was set), the period it weighed, the activities it cited (available false means that activity has since been deleted), and its outlook when it had one — trend, section statuses, and the race marks and odds or Run Fitness outlook, all the coach's own numbers at the time (race.curve is ARC's drawing of them). It is a dated record, not current truth: its evidence was never recomputed, and training since then may have changed the picture. Read the latest one before changing the athlete's plan, weigh it, and say so if it is out of date.

get_coach_assessment

Read one saved running session in full, including every step. Use it to show the athlete what a Pattern actually asks for before placing it, or as the starting point for a variation you then save back with save_workout_pattern.

get_workout_pattern

Evaluate a historical or explicitly selected activity id. The result leads with evaluation: when evaluation.basis is planned_workout, judge the session against that workout's steps and their targets (evaluation.workout.engine.segments) — not against the mile/km split primitives, which are supporting context only; when basis is scheduled_race, judge it as a race — against its steps (evaluation.workout) when the race carries them, otherwise against its target; only when basis is splits (nothing matched) are the split primitives the verdict. For a run the athlete says happened today, use analyze_today_run, and for one from an earlier day within the last 30 days, analyze_past_run, so the day is resolved server-side from a fresh usable provider response or, when no provider is usable, from activities already stored in ARC. Raw provider samples are never returned or persisted.

get_activity_analysis

Return locally stored detail for one activity, including ARC-owned evidence and feedback. When the athlete wrote their own note on the run, athlete_note carries it: it is the athlete's own account in their words (how it felt, conditions, a niggle) — weigh it in your read of the run, and never present it as your feedback; no tool writes it, the athlete edits it in the ARC web app. The result carries evaluation — what the session is judged against: when evaluation.basis is planned_workout, evaluate the run against that workout's steps and targets (evaluation.workout.engine.segments), not against the mile/km splits, which are supporting context; only when basis is splits (nothing matched) are the splits the verdict. For a non-running activity the result carries a cardio_load attribution (its duration contribution and a counted/not-counted reason) — relay it rather than inventing a score. For entitled private Strava prototype users, append compact transient provider detail from the seven-day private cache without returning raw stream samples. Accepts a local cached activity UUID.

get_activity_detail

Load the athlete's training context (running history, altitude, Run Fitness score, training constraints, coach notes, and their saved Plan Preferences) at the start of every session before giving advice. Also the tool to answer "what are my preferences/plan settings?". Read-only. Plan Preferences are what the athlete requested, not what their plan runs — say so if the two differ, and read the active plan (get_plan) for what they are actually training on. Returns the profile object, or {setup_required: true} if no profile exists yet — when setup_required is true, the result text explains how to onboard the athlete; offer onboarding, but if the athlete declines, coach from context gathered during the session.

get_athlete_profile

Read one chapter of ARC's authored coaching method. Call it for every topic a result lists under guidance_topics — before designing, explaining, or adjusting a plan, and before answering an athlete's request to change one — because the chapter overrides general training knowledge. Each chapter is short (a few KB): what to do, what never to do, and how to say it. A chapter already read this session does not need reading again. Returns the chapter text with its topic and description.

get_coaching_doc

Identify the ARC account represented by this authenticated ChatGPT connection. Returns a stable account ID and optional display email; it does not read training data.

get_profile

Return the active plan for the current focus. A week's training is the union of TWO arrays: workouts (training sessions) and scheduled_races (the goal race and any tune-ups). A race day carries an entry in scheduled_races and NO entry in workouts, so reading workouts alone shows race day as empty and makes race week look far shorter than it is — a week's target_miles counts both, and workout_miles + race_miles says how. Use scheduled_races[].id wherever a scheduled_race_id or race_id is required: get_race reads one, patch_race edits it, delete_race removes it, save_race enters a new one. The plan is tiered: every week of the block is present with its dates, phase, target_miles (and its workout_miles/race_miles split), scheduled_races, workout_count and quality_session_count, so the whole block's shape is always in view — but only two weeks carry their workouts: the week containing today (current_week_id) and the next, or the first two before the block starts and the last two after it ends. A week without a workouts key and workouts_omitted=true has workout_count sessions that were not loaded; detail_available=true means get_week_review with that week's id returns them now. A week without a workouts key and workout_count=0 has no training sessions; it has nothing scheduled only if scheduled_races is also empty — race week often holds the race and little else. Within a detailed week each workout omits its Structured Workout steps and is marked has_structure/step_count; fetch one workout's steps with get_planned_workout.

get_plan

Fetch one Planned Workout by id including its full Structured Workout steps (warmup / repeat / interval / recovery / cooldown with pace or power targets). The bulk plan views (get_plan, get_week_review, get_day_review, …) omit these steps to stay under the response size limit and flag each workout with has_structure/step_count; call this to load the steps for one workout when you need them.

get_planned_workout

Return the athlete's current five Power Zones from the Athlete Profile. Use before generating power-targeted workouts. Power is opt-in: pace stays the default target until the athlete has zones and sets workout_target_preference to power, so a pace athlete with no zones is the normal case, not a gap to fill.

get_power_zones

Read AgentRunCoach's product documentation. Use when an athlete asks what AgentRunCoach can do, how a feature works, or what to try next. Omit topic for the documentation index and athlete-worded examples, then call again with an exact topic for the full guide. Answer from these docs rather than reconstructing capability from tool names.

get_help

Get one of the athlete's races by id, upcoming or past. For a race that has happened, watch is the run that was the race and its time: stored when a run was linked or a review recorded it, otherwise the day's longest run (stored false). A watch time is not the result; official_time_sec is, when set. Say which one you quote.

get_race

Return the active Training Focus — what the athlete is training toward. Its kind is one of: race (a goal race, with a distance and possibly a date), distance (a distance goal with no race on the calendar), or fitness (general fitness, with neither). A focus stored before kinds existed reads as race.

get_focus

Return the athlete's Pace Profile: the named paces and five Training Zones (sec/km) at their stored Run Fitness, with any pace they have pinned applied and, when they have Power Zones, the watt band on every zone and on any pace they have pinned watts to — so pace and power read from one response. Call it with no argument for the athlete's own paces. Pass run_fitness_score only to project a hypothetical score ("what would I run at sea level"); a projection keeps the zone watts but carries no pinned paces or watts, since those are evidence at the athlete's real fitness. The race_equivalents are predicted from Run Fitness, never from a pinned pace: where a pace the athlete has pinned implies a different time at that distance, the entry also carries pinned_time_sec, and pinned_pace_source where that pin records its evidence, so you can say what disagrees with the prediction rather than silently preferring one.

get_training_paces

List prior coaching notes saved against an activity, newest first. Call this before generating fresh feedback on the same activity (or a similar one in a series) so you don't repeat prior advice. Returns one lane only.

list_activity_feedback

Read-only list of activities already stored in ARC. It does not fetch anything new, so a run the athlete's connected provider holds may not be here yet: to review a specific run from today or the last 30 days, use analyze_today_run or analyze_past_run for its day instead — they refresh from the provider first. Use this list to browse ARC's record or to find an older run by id. Call it BEFORE asking the athlete to describe or re-supply history ARC may already hold. What comes back is ARC's record, not the athlete's training: if it is empty, or thinner than what the athlete describes, do not conclude they have not been running — a stored provider connection is no guarantee that ARC holds their history, and the absence of one is no guarantee that there is nothing to collect. For a specific recent run, look it up for its day with analyze_today_run or analyze_past_run first; if it is still missing, ask them for a screenshot of a recent run from any fitness app — that is the most useful thing they can give you — and take a plain description if they have no screenshot. Save either with record_activity_evidence. from/to together must span at most 400 days.

list_cached_activities

List the athlete's saved Coach Assessments, newest first. Returns an index — id, title, the summary verdict, when it was saved, the period it weighed, the Training Focus it was measured against (null when they had none), and the headline of its outlook when it had one (trend direction, chance of the target time, the Stretch, Toss-up and Likely times — or the projected range on assessments saved before those existed — and the Run Fitness outlook) — not the reports; open one with get_coach_assessment. Read the headlines before writing a new outlook's trend: they are your earlier numbers to compare against. Read this history before starting a new plan, and when the athlete asks how their training has gone over time. One page at a time: when next_cursor is present there are more, so do not describe this page as their whole history — pass it back as cursor to read on.

list_coach_assessments

Detect near-duplicate activities in the cache (same start ±5min, distance within 2%).

list_duplicate_activities

List ARC's Training Plan library (ready-made, distance-specific plans) with style, load, and comparison metrics.

list_plan_templates

List race tags already stored locally.

list_race_tags

List the athlete's races, newest first: races already run, with their results, and upcoming races they have entered (no time yet). prescribed says whether a race is on the plan; outcome says how a past race ended when someone recorded it. Local-only: does not call any upstream provider.

list_races

List the reusable running sessions available to this athlete: the ones they saved themselves, plus the published shared set. Ordered in three groups — the athlete's starred workouts first, then their own, then ARC's shared ones — each newest first. Returns an index: id, name, type, step count, not the steps themselves; call get_workout_pattern for what a session actually asks for. Use it before writing a session from scratch — they may already have the one they want — and when swapping a planned day for something they like. One page at a time. When the result carries a next_cursor there are more workouts than were returned, so do not tell the athlete this is everything they have — pass that value back as cursor to read on. Set favorites true to read only what they have starred, which is the right call when they ask for a workout they like rather than for the whole library.

list_workout_patterns

List prior Training Blocks with planned metrics, execution metrics, and ARC optimization insights.

list_training_blocks

Record that the athlete performed a non-running planned workout — Strength, Cross-Training, or Mobility — that ARC has no recorded activity for, or withdraw that record with completed=false. Only these mark-only days qualify: they carry no distance or pace prescription, so marking one loses nothing. Running sessions are refused, because marking carries no distance and the run would read as done while contributing zero miles against its prescription — log the run with record_activity_evidence instead. Only today or an earlier date can be marked. A workout ARC can already see was completed by an activity is refused too: the activity is the better evidence and already completes it. Marking contributes no mileage, adherence, Cardio Load, or execution score; it records that the session happened.

mark_planned_workout_complete

Move a planned workout to another current or future date in the active plan, including across week boundaries (for example Sunday to Monday). Preserves the workout and its structure, enforces max 2 workouts per day and both weeks' mileage budgets, and refuses past dates.

move_planned_workout

Override the Execution Score for a historical or explicitly selected activity. The override is added to the run's history of coach scores: earlier coach scores and the deterministic engine score are kept, the latest override is the score shown, and repeating the latest override changes nothing. For a run the athlete says happened today, use analyze_today_run followed by save_today_run_review; for one from an earlier day they name, analyze_past_run followed by save_past_run_review. For a Scheduled Race, pass scheduled_race_id to attach an agent-only score; for a Planned Workout, run score_workout_execution first.

set_execution_score

Patch a plan week. Set phase/notes to correct the periodization label or add coaching notes. Set target_miles to replan (relayout) the week to a new weekly mileage: already-run days are kept, days from today on are rebuilt using the plan's knobs, the week budget (<= 105% of peak) is enforced, and the change is recorded as an adaptation event. Past weeks cannot be relaid.

patch_plan_week

Patch one planned workout's kind, type, terrain, distance, duration, name, or notes. Changing what a running session ASKS FOR must leave it with structure: this tool has no reps/interval_meters/work_block_minutes shorthand, so turning a day into intervals, hills or a threshold session means passing steps. Distance or duration alone is enough only for a plain easy or long run, which ARC rebuilds itself. A running session's title and description are RENDERED FROM ITS STEPS and are refused here — name the session with session_name, put coaching words in notes, and change what it asks for with steps. Title and description are accepted on a Strength, Cross-Training or Mobility day, which has no steps to render them from.

patch_planned_workout

Edit fields on one of the athlete's races — e.g. correct a finish time, date, distance, name, or location, set its target, record how it ended, link or relink the run that was the race, or take an upcoming race off the plan. Every field except prescribed stays editable after race day. Moving an upcoming race or changing its distance changes the plan days it holds and is refused when that pushes a week past its mileage budget. Requires a race_id from list_races or get_plan's scheduled_races. All fields are optional; only the fields you provide are changed, and passing an empty string to a text field (e.g. notes) clears it. An upcoming goal race's name, date, distance and target are edited through set_focus. To remove a race entirely use delete_race; to enter a new race use save_race.

patch_race

Edit ONE step of a planned workout in place: its length, a repeat count, or what it targets. To rewrite the session's whole structure use patch_planned_workout with steps[] instead. The pace_zone argument names the intensity; the service applies pace or power primary targets from the active plan. Select any nested step with step_path, or use the legacy step_order/step_type and optional child selectors. The workout's title and description re-render from the steps this edits, so they never need updating alongside it. A patch changes the plan only; pushing it to the athlete's watch is a separate step.

patch_workout_step

Compute a proposed plan + diff vs the active plan, from the athlete's saved Plan Preferences. Does NOT persist; call confirm_regenerate to apply. The result carries the proposal and a diff, never the plan being replaced — replaces_active_plan says whether there is one. Takes no arguments — to change the plan's shape (peak weekly miles, run days), patch the athlete's Plan Preferences first with patch_athlete_profile, then regenerate. A requested peak is honored; if it is more than the athlete's current plan level can shape, the proposal switches to the plan level at the SAME race distance that is built for it, and proposed.adjustment_reasons says so — relay that to the athlete before confirming. races lists the athlete's races this plan would pick up; one with over_budget pushes its week past the mileage limit and confirming takes it off the plan (it stays in their races) — tell the athlete before they confirm. The proposal is tiered like get_plan: every proposed week is listed with its dates, phase, target_miles, races and workout_count, and only two weeks carry their workouts — the week containing today and the next, or the first two before the block starts and the last two after it ends. Other proposed weeks say workouts_omitted=true and detail_available=false — a proposal is not saved, so get_week_review cannot read it; those sessions become readable once the proposal is confirmed.

regenerate_plan