A coach for the life you actually live.

# Connect Athos

Public setup instructions for the Athos MCP connection. Reading this page does not install a connection or publish a plugin.
Environment: production
MCP URL: https://app.athos.fitness/mcp
Transport: Streamable HTTP
Machine-readable setup: https://app.athos.fitness/connect/agent.json

## Boundaries

- Get user approval before changing client configuration. This page is setup documentation, not permission to install or connect.
- Do not overwrite an existing connection. Inspect it first; reuse it if its URL matches, otherwise ask the user.
- Never ask for the user's password or tokens in chat. Let the user sign in and consent in the Athos browser flow.
- Use the client's secure OAuth credential storage. Do not place credentials in URLs, prompts, or project files.
- Onboarding writes save interview progress and review corrections. Only explicit approval of the exact reviewed version may start program generation.
- Workout and program writes require program:write consent and the athlete’s explicit request. Completed history and workout logging remain in the app; replacement requires explicit confirmation.
- If your account or client does not support a user-approved MCP connection, give the user the setup link instead of claiming installation.

## Configure Codex

After user approval, inspect current connections, add Athos only if it is not already configured,
then start OAuth login. These are separate commands, not an unattended installer:

```sh
codex mcp list
codex mcp add athos --url https://app.athos.fitness/mcp
codex mcp login athos
```

The user must complete sign-in and consent. Refresh the client's tools or start a new conversation
if the new tools are not available in the current session.
Official instructions: https://learn.chatgpt.com/docs/extend/mcp?surface=cli

In Codex Desktop, open Settings > MCP servers and add a Streamable HTTP server with the URL above, then authenticate when prompted. Desktop and CLI share configuration on the same host; do not add a duplicate. Use /mcp to inspect active connections, then perform the authenticated reads below.

## Configure ChatGPT

In ChatGPT, on a supported account or workspace, add a user-approved MCP connection using the server URL, complete Athos OAuth sign-in or sign-up in the browser, then select the connection in a new conversation. Account and workspace policies may not allow custom MCP connections; this page cannot enable them or install a plugin for you.
Use this route for in-chat interview, saved progress, review, correction and explicit confirmation. Athos remains the source of truth; the user approves the exact review before generation starts. A public webpage or source package is not proof the connection is live or publicly listed.
Official instructions: https://developers.openai.com/plugins/deploy/connect-chatgpt

## Configure Claude web / Desktop

Open Customize > Connectors (Settings > Connectors in some versions), add a custom connector named Athos with the MCP URL above, then Connect and complete Athos browser sign-in and consent. Enable the connector in the conversation. Availability depends on account and workspace policy; Team/Enterprise may require an owner to add the connector first. Do not invent an OAuth client ID or secret.

Official instructions: https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp

## Configure Claude Code

Run /mcp inside Claude Code, select Athos, and complete browser OAuth. The add command uses the default local scope; choose a wider scope only with user approval. Inspect the connection and tools in /mcp, then perform the authenticated reads below.

```sh
claude mcp list
claude mcp add --transport http athos https://app.athos.fitness/mcp
```

Official instructions: https://code.claude.com/docs/en/mcp

## Configure Hermes

Use the intended Hermes profile. Adding the server may already open browser OAuth; run login in a fresh terminal if authorization is still needed. Complete Athos sign-in and consent. The test command checks initialization and tools/list, not authenticated athlete access. Refresh tools or start a new session, then perform the authenticated reads below. For a remote/headless host, follow Hermes's documented OAuth callback procedure; never paste callback URLs or tokens into chat.

```sh
hermes mcp list
hermes mcp add athos --url https://app.athos.fitness/mcp --auth oauth
hermes mcp login athos
hermes mcp test athos
```

Official instructions: https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp

## Configure Instinct (unverified client)

Custom MCP support is not verified for Instinct. This is separate from Meta's Muse Connector Platform below. Confirm the exact product and version first; Muse Code instructions do not establish support in a personal-agent app named Muse. If that product documents custom remote MCP with OAuth, add the MCP URL above in its supported connection settings and complete browser consent. It must support Streamable HTTP, OAuth discovery, dynamic client registration, and PKCE S256. Otherwise stop and share this guide; do not claim a connection or substitute a pasted API key. No client-specific install command is provided until official setup instructions are confirmed.

## Configure Meta Muse Connector Platform

Muse integrations go through the Muse Connector Platform submission and approval process. Submit the MCP URL above with OAuth discovery, PKCE S256, requested scopes, tool documentation and a dedicated synthetic review account. Athos offers a Read Only consent choice for program/onboarding reads; full coaching requires separately approved write access. Muse's public guide does not specify every transport or OAuth-client requirement; confirm these in the portal. Approval and a successful Muse-side test are required before claiming Athos is available there. Do not invent an install command or request pasted passwords, API keys or tokens.

Official instructions: https://platform.muse.ai/docs

## Other MCP clients

Use the MCP URL above. Discover OAuth at https://app.athos.fitness/.well-known/oauth-protected-resource/mcp.
Check that the discovered resource matches the MCP URL. Use the authorization server metadata,
dynamic client registration, authorization code flow with PKCE S256, and scope `app:open coaching:write onboarding:read onboarding:write program:read program:write`.
Use an existing MCP/OAuth client implementation; do not improvise token exchange or request athlete IDs. The athlete can approve the supported permissions together in one consent or choose Read Only; the server still enforces each tool's minimum permission. Respect the returned token scope and request a new approval only for an explicitly requested task that needs more access. Never ask for a pasted API key.
These are documented client procedures, not a claim that every client's Athos OAuth flow has been tested.
Listing tools alone does not prove authenticated access. If your client is not verified, report that limitation.

## Available tools

- `athos_get_connection` (program:read): Read the connected Athos athlete's delegated connection and program eligibility.
- `athos_get_program` (program:read): Read the connected athlete's canonical active Athos program.
- `athos_get_onboarding` (onboarding:read): Read the connected athlete's saved Athos onboarding progress, canonical question catalog, review, and generation status.
- `athos_save_onboarding_turn` (onboarding:write): Save one athlete answer during the Athos onboarding interview. ChatGPT conducts the interview; this does not create a program.
- `athos_prepare_onboarding_review` (onboarding:write): Save the completed interview and queue Athos's existing canonical extraction for review. This never confirms or replaces a program.
- `athos_correct_onboarding_review` (onboarding:write): Apply an athlete-approved correction to the exact reviewed Athos onboarding revision.
- `athos_confirm_onboarding` (onboarding:write): Confirm the exact review the athlete explicitly approved and start Athos's existing first-program generation flow.
- `athos_retry_initial_generation` (onboarding:write): Use only after the athlete asks to retry. Read the current failed generation first and pass its exact operation ID. This preserves the confirmed review and never replaces an active program.
- `athos_get_planning_questions` (program:read): Read the connected athlete's still-answerable coach planning questions and recorded assumptions.
- `athos_answer_planning_question` (coaching:write): Submit the athlete's stated answer to a specific Athos coach planning question. The Athos coach acknowledges it and decides whether future training needs adjustment. A queued answer is not a completed plan change.
- `athos_modify_workout` (program:write): Adapt one workout on the remaining days of the current training week, or move it to a later day within that week, using the athlete's explicit instruction and supplied context (time, equipment, travel). Use after reading the actual program and target day. Existing Athos authorities protect completed history. Returns queued work, not a saved edit; follow athos_get_change_status.
- `athos_replan_week` (program:write): Rearrange the remaining Athos training week when the athlete asks to change their schedule or constraints. Use fresh program/revision/cursor and include their stated context. Returns queued work; follow athos_get_change_status and required questions.
- `athos_update_program` (program:write): Update the remaining Athos program for the athlete's changed goals, availability or equipment while preserving completed history. Include their stated context. Returns queued work; inspect status and fresh program before claiming the change saved.
- `athos_replace_program` (program:write): Replace an active Athos program only after the athlete explicitly confirms that replacement. Use fresh program/revision/cursor and confirmed_by_user=true. Never use onboarding to replace an existing program. Returns queued work; follow status to publication.
- `athos_plan_next_week` (program:write): Ensure the exact next athlete-local Monday–Sunday is planned from the saved Athos program. Read the program first and supply its current program/revision/event cursor. This does not reinterpret instructions or save context. An already materialized week returns its canonical readback without queuing another week; changed=false and applied=false mean no new change was applied. New planning returns an owned weekly-fill operation; follow athos_get_change_status until publication. Reuse identical arguments and key after a timeout, including across midnight.
- `athos_get_change_status` (program:read): Read one requested Athos change by interaction_id or the operation_id returned by a direct workout edit. Includes any question awaiting the athlete and the linked operation. A decided interaction alone does not mean saved. Published operations include fresh canonical program readback; pending or failed work is not a completed change.
- `athos_answer_change_question` (program:write): Answer the actual clarification question returned by athos_get_change_status using the athlete's stated response and current question/version IDs. Supply exactly one selected option or free-text answer. Continue following status; queued is not applied.
- `athos_answer_operation_question` (program:write): Answer a programming operation's actual question with the athlete's stated response and current operation version/question IDs. Supply exactly one selected option or free-text answer; then inspect the linked change status again.
- `athos_get_workout` (program:read): Read the actual planned Athos workout with stable exercise/set IDs, dose and exact revision/content fences needed for an edit. Omit day_id for athlete-local today; otherwise use a day returned by athos_get_program. Supply execution_id instead of day_id to read an in-progress workout: execution_version, editable remaining IDs, completed work and protected running blocks.
- `athos_search_exercises` (program:read): Find eligible exercises in the planned day's or live execution's pinned catalog, filtered by the athlete's equipment and canonical restrictions. Supply a movement pattern, modality, block type or name. Pass an environment override only when the athlete stated different equipment/venue, and use the same override for the edit. Never invent exercise IDs.
- `athos_edit_workout` (program:write): Save the athlete's explicit exercise, set, rep, load, rest or block changes atomically to a planned workout or the unfinished remainder of an active execution. For planned edits, read athos_get_workout and use its exact program/revision/cursor/day/content/session IDs. Use catalog candidates for new exercises and a stable idempotency key for retries. Set op_list.reason to the athlete's request; use time_limit only for their stated time limit. All ops succeed together or none are saved. For active edits use execution_id and expected_execution_version from athos_get_workout, without planned-workout fences. Completed work and running timed blocks are protected; this does not log workouts.
- `athos_open_app` (app:open): Open the connected athlete's actual Athos app after they choose panel or browser. Use presentation=panel to show the app beside this conversation where supported; use presentation=browser to provide a private single-use Open/Copy link without loading the panel. Each request issues a fresh two-minute handoff. The same saved account and program are used by chat and the app. Requires app-access consent. Account security, data-sharing setup and administration require direct Athos sign-in. Never copy private handoff metadata into chat; hosts without app UI can use the ordinary returned URL and sign in.

## Interview, generation and opening Athos

- Read the authenticated connection and saved onboarding first; resume rather than restart. Introduce a new interview as about 5 minutes. Offer to reuse only relevant explicit facts already shared, confirm the proposed details once before saving, and ask only missing questions.
- After the athlete approves the exact review and Athos accepts generation, promptly explain that building usually takes about 15 minutes and can take longer. They may leave and return. Offer the optional TestFlight app and coach texting only according to the returned activation state; never promise an unverified text.
- Offer to open Athos beside the conversation or provide a fresh single-use browser link. Call athos_open_app with presentation=panel or presentation=browser only after the athlete chooses. Browser presentation must not load the panel or open a window automatically. The secure card offers Open/Copy and obtains a new two-minute link for each action; never reuse a handoff already consumed by the panel.
- App access requires app:open, requested with the connection's other permissions in one connection consent. The athlete may choose Read Only instead; then onboarding saves, plan changes and signed-in app handoffs require a new connection approval. Account security, data-sharing setup and administration require direct Athos sign-in. Never copy private _meta handoff credentials into chat, prompts, logs, or project files. Hosts without app UI can share the ordinary returned Athos URL and use normal sign-in; do not claim a panel opened or a single-use signed-in link was delivered there.

## Verify before onboarding or coaching

Call `athos_get_connection` and `athos_get_onboarding` first. If coaching an existing athlete, read the active program with `athos_get_program`.
- Complete MCP initialization and tools/list; confirm the documented program and onboarding tools are present.
- A tool error (isError=true) is not success; do not claim the connection or saved state is verified.
- Read the authenticated connection and onboarding state before deciding whether to resume, start, or coach.
- Use athos_get_program only when a current program is available and the user asks for program coaching.
- Never claim interview progress, a correction, confirmation, or a ready program unless Athos returns it.
- Only athos_confirm_onboarding may confirm the reviewed revision and start generation, after explicit user approval.
- Pass the review_token from the current Athos read unchanged, with its exact revision/version and approval=true; never reuse it after a correction.

On an authentication error, reconnect through OAuth. If setup or a read fails, report the failure;
do not claim the user is connected or that onboarding/program state was saved. An active program must not be replaced by onboarding.

Suggested first request: Start or resume my Athos onboarding. Check what is already saved before asking me questions. Offer to summarize relevant fitness details I have shared in this conversation, then let me confirm what to reuse before saving.