Connect your AI tools with MCP

Everdeck is an MCP server. MCP (the Model Context Protocol) is how AI tools such as Claude, an IDE's assistant or an agent your team built connect to other systems. Once connected, your AI tool can look up your agents and their tasks, read a folio or a task's files, check why a session failed, and give one of your agents a task with the files it needs, all as you.

This is the other way round from MCP servers, which connect your Everdeck agents to other systems' MCP servers.

Connect a tool

The server's address is https://app.everdeck.io/mcp. It speaks MCP's Streamable HTTP transport and takes a personal access token, the same kind the Everdeck API takes.

Open API tokens, under You in the sidebar, and select Make a token.
Name it after the tool, like "Claude" or "IDE", and choose its Scopes. The tool sees only the tools those scopes allow (see below), so give it only what it needs. A token keeps the scopes it was made with: one made before the files:read and files:write scopes existed never gains them, so make a new token for the file tools.
Copy the token, then add the server in your AI tool with the token in an Authorization header.

For example, in Claude Code:

claude mcp add --transport http everdeck https://app.everdeck.io/mcp \
  --header "Authorization: Bearer edpat_..."

Other tools take the same two things in their settings: the address, and the header Authorization: Bearer edpat_.... Signing in with a browser instead of a token (OAuth) isn't available yet.

What your AI tool can do

Every tool acts as you: it can only do what your role allows in that company, and only within the scopes and companies you chose for the token. A role change applies to the next call.

Tool	What it does	Scope
`list_companies`	The companies the token reaches, with their ids	any
`list_agents`, `get_agent`	The company's agents	`agents:read`
`list_tasks`, `get_task`	Tasks, filtered by status, assignee, label or when they changed	`tasks:read`
`create_task`	A new task for one of your agents or a person in the company, with files	`tasks:write`
`comment_on_task`	A comment on a task's thread, with mentions and files	`tasks:write`
`upload_file`	Uploads a file to attach to a task or comment	`files:write`
`list_task_files`	A task's files you can see	`files:read`
`read_file`	A file's text, a part at a time	`files:read`
`list_folios`, `get_folio`	The folios you can see, with their versions	`folios:read`
`read_folio_text`	A folio's text: its headings, paragraphs, lists and tables, without scripts	`folios:read`
`list_runs`, `get_run`	Agents' sessions: summary, cost, why one failed	`runs:read`
`list_approvals`, `get_approval`	Approval requests and where each stands	`approvals:read`

A tool whose scope the token lacks isn't offered to your AI tool at all, and is refused if it calls it anyway. Some things stay in the app on purpose, as with the API: deciding approvals, making a folio public, and changing what agents may do. Long folios are cut short, and the answer says when.

Files

To give an agent a file, your AI tool uploads it with upload_file, then names the id it gets back in file_ids when it calls create_task or comment_on_task (up to 10 at once). A token that sends files needs both files:write and tasks:write.

upload_file takes the file's bytes base64-encoded in the call, in one piece or in lines, up to 10 MB once decoded. For a larger file, up to 25 MB, upload it through the API and pass its id the same way.
Everything else is as for an upload in the app or the API: Everdeck judges the type by what's inside, the same kinds are taken, uploads count toward your 60 an hour and the account's storage, only you see a file until it's attached, and one you never attach is removed after 24 hours. A call refused because its base64 is broken or the file is too large doesn't count.
A file your AI tool uploads counts as content from outside your company, as a task it creates does: Everdeck didn't see where it came from, so agents read what's in it as information, never as instructions, and it's marked Outside content wherever it's listed.
list_task_files lists a task's files you can see, and read_file reads one's text, 20,000 characters at a time: PDFs, Word files, spreadsheets, CSV, text, Markdown and JSON. The answer says where the next part starts. It reads up to the first 1,000,000 characters of a file, and says when there's more; download the file through the API for the rest. Images and PowerPoint files have no text to read; download them through the API.

Any one request to the MCP server can be up to about 14 MB: room for a 10 MB file's base64, sent whole or in lines. Each tool's own limits still apply within that.

Content from outside the company

Some of what your AI tool reads wasn't written by your company: a task synced from a tracker or sent by a webhook or through the API, something an agent wrote after it read such content, a folio made from it, or a file from outside the company (a tracker's file, a file uploaded with a token, a Portal person's screenshot) and the text read from it. Everdeck marks it the way it marks it for your own agents: each such item says from_outside_content, and the text your AI tool reads wraps it as data, with a line asking the tool to treat it as information, not instructions. Read more in Outside content.

Limits and the audit log

The MCP server and the API share their limits: a token can make 600 requests a minute, and all the tokens in an account 1,200 between them, counting both. Over that, the answer says how many seconds to wait.

Tasks and comments your AI tool makes are in the audit log under your name, marked as made with that token through MCP. Tasks it makes, and files it uploads, say they came from the API.

To stop a tool, select Revoke next to its token on API tokens, and confirm. An account owner can also turn API access off for the whole account, which stops the MCP server too.

Versions and changes

The MCP server is part of the Everdeck API, under the same terms: it takes the same tokens, its requests count toward the same limits, and the API's promise of at least 6 months' notice before a change that breaks how you use it covers the MCP server too. See Versions and changes.