FeaturesShared workspacesFor teamsChatGPT & ClaudeMCP serverProduct tourBlogPricingLog in
✦
Model Context Protocol

One URL. 57 tools.
Your real productivity data.

EvyOS ships a remote MCP server over your tasks, projects, goals, habits, skills, notes and calendar. OAuth 2.1 with PKCE, dynamic client registration, nothing to paste but the URL, and access you can revoke from Settings.

Serverhttps://api.evyos.com/mcp

Try Pro free for 14 days →What it feels like to use

Connecting a client is a Pro feature. The trial does not need a card.

✦ Connecting

Nothing to install.

The client does the discovery. You paste a URL and approve a screen.

1
Add the connector

In ChatGPT or Claude, add a connector with the URL https://api.evyos.com/mcp. Any other MCP client that supports remote servers with OAuth takes the same URL.

2
The client discovers the rest

An unauthenticated call returns a 401 carrying WWW-Authenticate with a pointer to the protected-resource metadata. From there the client finds the authorization server, registers itself under RFC 7591, and starts a PKCE flow. None of this is anything you do.

3
You sign in and consent

Your browser opens EvyOS, you sign in as normal, and a consent screen names the application that asked and what it wants: evyos:read, evyos:write and offline_access. Approve it and you are returned to the client. This is the step that requires Pro.

4
It calls tools as you

The client holds an EvyOS token, not your Clerk session. Every tool call runs as a request against the same API the web app uses, under your identity and your plan.

+
For clients that cannot do OAuth

A CLI, a script or a self-hosted agent can use a long-lived key instead. Mint one in Settings and send it as a bearer token. It never expires, so disconnecting it in Settings is the only way it ends — treat it like any other secret.

✦ Tool catalogue

57 tools, nine groups.

The whole product, not a read-only slice. Updates are partial — a client sends only the fields that change — and the specific tool is always preferred over a generic update, so completing a task is evyos_complete_task rather than setting a status field.

Overview and search4
evyos_get_todayevyos_searchevyos_get_weekly_summaryevyos_list_workspaces
Tasks9
evyos_list_tasksevyos_get_taskevyos_create_taskevyos_update_taskevyos_complete_taskevyos_delete_taskevyos_add_subtaskevyos_toggle_subtaskevyos_add_task_comment
Projects7
evyos_list_projectsevyos_get_projectevyos_create_projectevyos_update_projectevyos_delete_projectevyos_add_project_milestoneevyos_complete_project_milestone
Goals7
evyos_list_goalsevyos_get_goalevyos_create_goalevyos_update_goalevyos_delete_goalevyos_add_goal_milestoneevyos_complete_goal_milestone
Habits8
evyos_get_todays_habitsevyos_list_habitsevyos_get_habitevyos_create_habitevyos_update_habitevyos_delete_habitevyos_complete_habitevyos_uncomplete_habit
Skills7
evyos_list_skillsevyos_get_skillevyos_create_skillevyos_update_skillevyos_delete_skillevyos_log_practiceevyos_add_skill_resource
Notes7
evyos_list_notesevyos_get_noteevyos_create_noteevyos_update_noteevyos_delete_noteevyos_list_note_foldersevyos_create_note_folder
Calendar6
evyos_list_eventsevyos_get_eventevyos_create_eventevyos_update_eventevyos_delete_eventevyos_complete_event
Deep research pair2
searchfetch
✦ How it is built

Boring on purpose.

The interesting decisions here are the ones that stop the connector becoming a second, subtly different product.

🔗
Same API, not a copy

Each tool call is dispatched as an in-process request against the same application that serves the app. Nothing reimplements product logic, so quotas, workspace scoping, activity logging and cache invalidation are inherited rather than reproduced.

🌐
Stateless by design

No session is held between requests. Every call carries its own bearer token, which means the server scales horizontally with no affinity and a restart never drops a connection mid-conversation.

🔐
Tokens you can kill

Access and refresh tokens are stored hashed and rotate on refresh. Revoking a connection in Settings invalidates every token under it at once, and a connected app can never authorise another one.

👤
One person, one grant

A connection belongs to the account that approved it and sees only that account's data, including the shared workspaces that account is a member of. Nothing crosses between users.

📊
Plan-aware

A connection carries a snapshot of your plan, refreshed whenever you open Settings. Upgrading to Pro lifts the connector's limits on your next visit instead of requiring a reconnect.

📜
Instructions up front

The server sends the model the record model once, at connection time — how goals, projects and tasks ladder, that habits are per-day records, that deleting is not the same as finishing. It asks far better questions as a result.

✦ Questions

Technical questions.

https://api.evyos.com/mcp. That is the only thing you paste. Discovery, registration, authorisation and the token exchange are all found from there by the client.
Streamable HTTP, answering in JSON. The server is stateless — every request carries its own bearer token and nothing is held between them — so it scales across replicas with no session affinity. It implements initialize, tools/list, tools/call and ping, and negotiates protocol versions 2025-06-18, 2025-03-26 and 2024-11-05.
It is an OAuth 2.1 authorization server with PKCE, RFC 7591 dynamic client registration and refresh-token rotation. A 401 carries the WWW-Authenticate header pointing at the protected-resource metadata, which is how a client discovers where to authenticate. You sign in with your normal EvyOS account and approve a consent screen; the client never sees your credentials.
Three: evyos:read, evyos:write and offline_access. Read and write cover the tools; offline access is what lets the client refresh its token rather than sending you back to a consent screen every hour.
Yes. Approving a connection — and minting an API key — requires a Pro account, at $9.99 per month or $99 per year, with a 14-day trial that does not ask for a card. Discovery and the 401 challenge are open, but the consent step is where the plan is checked.
Not for ChatGPT or Claude — they run the OAuth flow, so there is no key to generate, store, paste or leak. For a client that cannot do OAuth, such as a CLI, a script or a self-hosted agent, you can mint a long-lived key in Settings and send it as a bearer token instead. It does not expire; disconnecting is how it ends.
Yes. Most tools take an optional workspaceId and act inside that shared workspace; without one they act on your personal space. evyos_list_workspaces tells the model which spaces exist and what their ids are.
Every tool call is executed as an in-process request against the same FastAPI application that serves the web app, rather than through a parallel implementation. Quotas, workspace scoping, activity logging and cache invalidation are inherited from the real route, so a tool cannot drift away from what the endpoint does.
They are the pair ChatGPT's deep research mode expects: search returns matching records with ids, fetch returns one record in full. Regular use goes through the specific tools instead — evyos_search when the model needs an id, then the tool for the thing it is doing.
Open Settings in EvyOS and revoke the connection. That invalidates every access and refresh token issued under it immediately. Connections also list when they were created and last used, so an app you have forgotten about is easy to spot.

The server is already running.
You just need an account to point it at.

Create one free, paste the URL into your client, and approve the consent screen.

Start for free →