fast-ioCloud file management and collaboration platform. Complete agent guide with all 258 tools — parameters, workflows, ID formats, and constraints. Use this skill when the user needs to store files, create branded shares (Send/Receive/Exchange), or query documents using built-in RAG AI. Supports transferring ownership to humans, managing workspaces, and real-ti…
Independent GitHub snapshot · Automated classification · Original documentation governs
Version: 1.35 Last Updated: 2026-02-06
The complete guide for AI agents using the Fast.io MCP server. Covers why and how to use the platform: product capabilities, the free agent plan, authentication, core concepts (workspaces, shares, intelligence, previews, comments, URL import, real-time collaboration, ownership transfer), 10 end-to-end workflows, and all 258 tools organized by module.
Platform reference. For a comprehensive overview of Fast.io's capabilities, the agent plan, key workflows, and upgrade paths, see references/REFERENCE.md.
Store files. Share with humans. Query with AI. All through one API -- free.
Fast.io is a cloud storage and collaboration platform that gives AI agents a complete file management, sharing, and intelligence layer. Upload outputs, create branded data rooms, ask questions about documents using built-in RAG, and hand everything off to a human when the job is done. No infrastructure to manage, no subscriptions to set up, no credit card required.
AI agents generate files, reports, datasets, and deliverables -- but getting those outputs to humans is messy. You end up cobbling together S3 buckets, presigned URLs, email attachments, and custom download pages. Every agent reinvents file sharing, and none of it looks professional.
When agents need to understand documents -- not just store them -- they have to download files, parse dozens of formats, build search indexes, and manage their own RAG pipeline. That is a lot of infrastructure for what should be a simple question: "What does this document say?"
| Problem | Fast.io Solution |
|---|---|
| Nowhere professional to put agent outputs | Branded workspaces and data rooms with file preview for 10+ formats |
| Sharing files with humans is awkward | Purpose-built shares (Send, Receive, Exchange) with link sharing, passwords, expiration |
| Collecting files from humans is harder | Receive shares let humans upload directly to you -- no email attachments |
| Understanding document contents | Built-in AI reads, summarizes, and answers questions about your files |
| Building a RAG pipeline from scratch | Enable intelligence on a workspace and files are automatically indexed, summarized, and queryable |
| Finding the right file in a large collection | Semantic search finds files by meaning, not just filename |
| Handing a project off to a human | One-click ownership transfer -- human gets the org, agent keeps admin access |
| Tracking what happened | Full audit trail with AI-powered activity summaries |
| Cost | Free. 50 GB storage, 5,000 monthly credits, no credit card |
This MCP server exposes 267 tools that cover the full Fast.io REST API surface. Every authenticated API endpoint has a corresponding tool, and the server handles session management automatically.
Once a user authenticates, the auth token is stored in the server session and automatically attached to all subsequent API calls. There is no need to pass tokens between tool invocations.
mcp.fast.iomcp.fastdev1.comTwo transports are available on each:
/mcp -- the preferred transport for new integrations./sse -- a legacy transport maintained for backward compatibility.The server exposes two MCP resources that clients can read directly via resources/list and resources/read:
| URI | Name | Description | MIME Type |
|---|---|---|---|
skill://guide | skill-guide | Full agent guide (this document) with all 267 tools, workflows, and platform documentation | text/markdown |
session://status | session-status | Current authentication state: authenticated boolean, user_id, user_email, token_expires_at (Unix epoch), token_expires_at_iso (ISO 8601) | application/json |
The server provides 8 guided prompts for common operations via prompts/list and prompts/get:
| Prompt | Description |
|---|---|
get-started | Complete onboarding: create account, org, and workspace. Covers new agents, returning users, and invited agents. |
create-share | Guide for creating shares. Explains Send/Receive/Exchange types, helps choose the right one, lists parameters. |
ask-ai | Guide for AI chat. Explains scoping (folder/file scope vs attachments), intelligence requirements, polling. |
upload-file | Choose the right upload method. Single-step upload-text-file vs chunked flow for binary/large files. |
transfer-to-human | Transfer org ownership to a human. Explains the process, implications, and claim URL workflow. |
discover-content | Find all accessible orgs/workspaces. Explains internal vs external orgs and why both tools are needed. |
invite-collaborator | Invite people to orgs, workspaces, or shares. Explains permission levels and message requirements. |
setup-branding | Customize branding. Explains asset hierarchy (org → workspace → share) and upload methods. |
Authentication is required before calling any tool except these unauthenticated tools:
system-statuspingauth-signinauth-signupauth-set-api-keyauth-email-checkauth-password-reset-requestauth-password-resetquickshare-detailsThere are three ways to use Fast.io as an agent, depending on whether you are operating autonomously or assisting an existing human user.
Option 1: Autonomous Agent -- Create an Agent Account
If you are operating independently (storing files, running workflows, building workspaces for users), create your own agent account with auth-signup. Agent accounts get the free agent plan (50 GB, 5,000 monthly credits) and can transfer orgs to humans when ready. This is the recommended path for autonomous agents. See Agent Account Creation below for steps.
Option 2: Assisting a Human -- Use Their API Key
If a human already has a Fast.io account and wants your help managing their files, workspaces, or shares, they can create an API key for you to use. No separate agent account is needed -- you operate as the human user. The human creates a key at Settings -> Devices & Agents -> API Keys (direct link: https://go.fast.io/settings/api-keys). Call auth-set-api-key with the key to authenticate -- the key is validated and stored in the session automatically. API keys are a 1:1 replacement for JWT tokens: they work as Bearer tokens with the same permissions as the account owner and do not expire unless revoked. Agents can also manage API keys programmatically with auth-api-key-create, auth-api-key-list, and auth-api-key-delete.
Option 3: Agent Account Invited to a Human's Org
If you want your own agent identity but need to work within a human's existing organization, create an agent account with auth-signup, then have the human invite you to their org with org-invite-member or to a workspace with workspace-member-add. Alternatively the human can invite via the UI: Settings -> Your Organization -> Manage People. This gives you access to their workspaces and shares while keeping your own account separate. After accepting invitations with user-invitations-accept-all, use auth-signin to authenticate normally. Note: If the human only invites you to a workspace (not the org), the org will appear as external -- see Internal vs External Orgs in the Organizations section.
| Scenario | Recommended Approach |
|---|---|
| Operating autonomously, storing files, building for users | Create an agent account with your own org (Option 1) |
| Helping a human manage their existing account | Ask the human to create an API key for you (Option 2) |
| Working within a human's org with your own identity | Create an agent account, have the human invite you (Option 3) |
| Building something to hand off to a human | Create an agent account, build it, then transfer the org (Option 1) |
Credit limits by account type: Agent accounts (Options 1, 3) can transfer orgs to humans when credits run out -- see Ownership Transfer in section 3. Human accounts (Option 2) cannot use the transfer/claim API; direct the human to upgrade their plan at https://go.fast.io/settings/billing or via org-billing-create.
auth-signin with email and password.auth_token and stores it in the session automatically.When creating a new account (Options 1 and 3 above), agents MUST use auth-signup which automatically registers with agent=true. Never sign up as a human account. Agent accounts provide:
account_type set to "agent"Steps:
auth-email-check with the desired email to verify it is available for registration before attempting signup.auth-signup with first_name, last_name, email, and password. The agent=true flag is sent automatically by the MCP server.auth-email-verify with email to send a verification code, then call auth-email-verify again with email and email_token to validate the code.auth-signin with email and password.two_factor_required: true, the returned token has limited scope.auth-2fa-verify with the 2FA code (TOTP, SMS, or WhatsApp).auth-status -- checks the local Durable Object session. No API call is made. Returns authentication state, user ID, email, and token expiry.auth-check -- validates the token against the Fast.io API. Returns the user ID if the token is still valid.JWT tokens last 1 hour. API keys (used when assisting a human) do not expire unless revoked. When a JWT session expires, tool calls return a clear error indicating that re-authentication is needed. Call auth-signin again to establish a new session. The MCP server does not auto-refresh tokens.
Tip: For long-running sessions, use auth-status to check remaining token lifetime before starting a multi-step workflow. If the token is close to expiring, re-authenticate first to avoid mid-workflow interruptions.
Call auth-signout to clear the stored session from the Durable Object.
Organizations are the top-level container in Fast.io. Every user belongs to one or more organizations. Organizations have:
Organizations are identified by a 19-digit numeric profile ID or a domain string.
IMPORTANT: When creating orgs, agents MUST use org-create which automatically assigns billing_plan: "agent". This ensures the org gets the free agent plan (50 GB, 5,000 credits/month). Do not use any other billing plan for agent-created organizations.
To discover all available orgs, agents must call both endpoints:
list-orgs -- returns internal orgs where you are a direct member (member: true)orgs-external -- returns external orgs you access via workspace membership only (member: false)An agent that only checks list-orgs will miss external orgs entirely and won't discover the workspaces it's been invited to. External orgs are the most common pattern when a human invites an agent to help with a specific project -- they add the agent to a workspace but not to the org itself.
Internal orgs (member: true) -- orgs you created or were invited to join as a member. You have org-level access: you can see all workspaces (subject to permissions), manage settings if you're an admin, and appear in the org's member list.
External orgs (member: false) -- orgs you can access only through workspace membership. You can see the org's name and basic public info, but you cannot manage org settings, see other workspaces, or add members at the org level. Your access is limited to the specific workspaces you were explicitly invited to.
Example: A human invites your agent to their "Q4 Reports" workspace. You can upload files, run AI queries, and collaborate in that workspace. But you cannot create new workspaces in their org, view their billing, or access their other workspaces. The org shows up via orgs-external -- not list-orgs. If the human later invites you to the org itself, the org moves from external to internal.
Workspaces are file storage containers within organizations. Each workspace has:
Workspaces are identified by a 19-digit numeric profile ID.
Workspaces have an intelligence toggle that controls whether AI features are active:
Intelligence OFF -- the workspace is pure file storage. You can still attach files directly to an AI chat conversation (up to 10 files), but files are not persistently indexed. This is fine for simple storage and sharing where you do not need to query your content.
Intelligence ON -- the workspace becomes an AI-powered knowledge base. Every file uploaded is automatically ingested, summarized, and indexed. This enables:
Intelligence defaults to ON for workspaces created via the API by agent accounts. If you are just using Fast.io for storage and sharing, disable it to conserve credits. If you need to query your content, leave it enabled.
Agent use case: Create a workspace per project or client. Enable intelligence if you need to query the content later. Upload reports, datasets, and deliverables. Invite the human stakeholders. Everything is organized, searchable, and versioned.
For full details on AI chat types, file context modes, AI state, and how intelligence affects them, see the AI Chat section below.
Shares are purpose-built spaces for exchanging files with people outside your workspace. They can exist within workspaces and have three types:
| Mode | What It Does | Agent Use Case |
|---|---|---|
| Send | Recipients can download files | Deliver reports, exports, generated content |
| Receive | Recipients can upload files | Collect documents, datasets, user submissions |
| Exchange | Both upload and download | Collaborative workflows, review cycles |
When creating a share with share-create, the storage_mode parameter determines how files are stored:
room (independent storage, default) -- The share has its own isolated storage. Files are added directly to the share and are independent of any workspace. This creates a self-contained data room -- changes to workspace files do not affect the room, and vice versa. Use for final deliverables, compliance packages, archived reports, or any scenario where you want an immutable snapshot.
shared_folder (workspace-backed) -- The share is backed by a specific folder in a workspace. The share displays the live contents of that folder -- any files added, updated, or removed in the workspace folder are immediately reflected in the share. No file duplication, so no extra storage cost. To create a shared folder, pass storage_mode=shared_folder and folder_node_id={folder_opaque_id} when creating the share. Note: Expiration dates are not allowed on shared folder shares since the content is live.
Both modes look the same to share recipients -- a branded data room with file preview, download controls, and all share features. The difference is whether the content is a snapshot (room) or a live view (shared folder).
Shares are identified by a 19-digit numeric profile ID.
Agent use case: Generate a quarterly report, create a Send share with your client's branding, set a 30-day expiration, and share the link. The client sees a professional, branded page with instant file preview -- not a raw download link.
Files and folders are represented as storage nodes. Each node has an opaque ID (a 30-character alphanumeric string, displayed with hyphens, e.g. f3jm5-zqzfx-pxdr2-dx8z5-bvnb3-rpjfm4). The special value root refers to the root folder of a workspace or share, and trash refers to the trash folder.
Key operations on storage nodes: list, create-folder, move, copy, rename, delete (moves to trash), purge (permanently deletes), restore (recovers from trash), search, add-file (link an upload), and add-link (create a share reference).
Nodes have versions. Each file modification creates a new version. Version history can be listed and files can be restored to previous versions.
Notes are a storage node type (alongside files and folders) that store markdown content directly on the server. They live in the same folder hierarchy as files, are versioned like any other node, and appear in storage listings with type: "note".
Create notes with workspace-create-note and update with workspace-update-note.
Creating: Provide workspace_id, parent_id (folder opaque ID or "root"), name (must end in .md, max 100 characters), and content (markdown text, max 100 KB).
Updating: Provide workspace_id, node_id, and at least one of name (must end in .md) or content (max 100 KB).
| Constraint | Limit |
|---|---|
| Content size | 100 KB max |
| Filename | 1-100 characters, must end in .md |
| Markdown validation | Code blocks and emphasis markers must be balanced |
| Rate limit | 2 per 10s, 5 per 60s |
In an intelligent workspace, notes are automatically ingested and indexed just like uploaded files. This makes notes a way to bank knowledge over time -- any facts, context, or decisions stored in notes become grounding material for future AI queries.
When an AI chat uses folder scope (or defaults to the entire workspace), notes within that scope are searched alongside files. The AI retrieves relevant passages from notes and cites them in answers.
Key behaviors:
ai_state: ready are searchable via RAGfiles_attach (if they have a ready preview)Use cases:
Notes support the same storage operations as files and folders: move (workspace-move), copy (workspace-copy), delete/trash (workspace-delete), restore (workspace-restore), version history (workspace-versions-list), and details (workspace-storage-details).
https://{domain}.fast.io/workspace/{folder_name}/storage/root?note={note_id}https://{domain}.fast.io/workspace/{folder_name}/preview/{note_id}AI chat lets agents ask questions about files stored in workspaces and shares. Two chat types are available, each with different file context options.
AI chat is read-only. It can read, analyze, search, and answer questions about file contents, but it cannot modify files, change workspace settings, manage members, or access events. Any action beyond reading file content — uploading, deleting, moving files, changing settings, managing shares, reading events — must be done through the MCP tools directly. Do not attempt to use AI chat as a general-purpose tool for workspace management.
chat — Basic AI conversation with no file context from the workspace index. Use for general questions only.chat_with_files — AI grounded in your files. Two mutually exclusive modes for providing file context:
ready AI state.Both types augment answers with web knowledge when relevant.
For chat_with_files, choose one of these mutually exclusive approaches:
| Feature | Folder/File Scope (RAG) | File Attachments |
|---|---|---|
| How it works | Limits RAG search space | Files read directly by AI |
| Requires intelligence | Yes | No |
| File readiness requirement | ai_state: ready | Ready preview |
| Best for | Many files, knowledge retrieval | Specific files, direct analysis |
| Max references | 100 files or folders | 10 files |
| Default (no scope given) | Entire workspace | N/A |
Scope parameters (requires intelligence):
folders_scope — comma-separated nodeId:depth pairs (depth 1-10, max 100). Limits RAG to files within those folders.files_scope — comma-separated nodeId:versionId pairs (max 100). Limits RAG to specific indexed files.Attachment parameter (no intelligence required):
files_attach — comma-separated nodeId:versionId pairs (max 10). Files are read directly, not via RAG.files_scope/folders_scope and files_attach are mutually exclusive — sending both will error.
The workspace intelligence toggle (see Workspaces above) controls whether uploaded files are auto-ingested, summarized, and indexed for RAG. When intelligence is enabled, each file has an ai_state indicating its readiness:
| State | Meaning |
|---|---|
disabled | AI processing disabled for this file |
pending | Queued for processing |
in_progress | Currently being ingested and indexed |
ready | Complete — available for folder/file scope queries |
failed | Processing failed |
Only files with ai_state: ready are included in folder/file scope searches. Check file state via workspace-storage-details.
When to enable intelligence: You need scoped RAG queries, cross-file search, auto-summarization, or a persistent knowledge base.
When to disable intelligence: The workspace is for storage/sharing only, or you only need to analyze specific files via attachments. Saves credits (ingestion costs 10 credits/page, 5 credits/sec for video).
Even with intelligence off, chat_with_files with file attachments still works.
With folder/file scope (RAG): Write questions likely to match content in indexed files. The AI searches the scope, retrieves passages, and cites them.
With file attachments: Be direct — the AI reads the full file content. No retrieval step.
Personality: The personality parameter controls the tone and length of AI responses. Pass it when creating a chat or sending a message:
concise — short, brief answersdetailed — comprehensive answers with context and evidence (default)Use concise when you need a quick fact, a yes/no answer, or a brief summary. Use detailed (or omit the parameter) when you need thorough analysis with supporting evidence and citations. The personality can also be overridden per follow-up message.
Controlling verbosity in questions: You can also guide verbosity through how you phrase the question itself:
Combining personality: "concise" with a direct question produces the shortest answers and uses the fewest AI credits.
Create a chat with ai-chat-create (workspace) or share-ai-chat-create (share):
type (required) — chat or chat_with_filesquery_text (required for workspace, optional for share) — initial message, 2-12,768 characterspersonality (optional) — concise or detailed (default: detailed)privacy (optional) — private or public (default: public)files_scope (optional) — nodeId:versionId,... (max 100, requires chat_with_files + intelligence)folders_scope (optional) — nodeId:depth,... (depth 1-10, max 100, requires chat_with_files + intelligence)files_attach (optional) — nodeId:versionId,... (max 10, mutually exclusive with scope params)Send follow-ups with ai-message-send (workspace) or share-ai-message-send (share). The chat type is inherited from the parent chat. Each follow-up can update the scope, attachment, and personality parameters.
After creating a chat or sending a message, the AI response is asynchronous. Message states progress: ready → in_progress → complete (or errored).
Recommended: Call ai-message-read (or share-ai-message-read) with the returned message_id. The tool polls automatically (up to 15 attempts, 2-second intervals, ~30 seconds). If the response is still processing after that window, use activity-poll with the workspace/share ID instead of calling the read tool in a loop — see Activity Polling in section 7.
Completed AI responses include citations pointing to source files:
nodeId — storage node opaque IDversionId — file version opaque IDentries[].page — page numberentries[].snippet — text excerptentries[].timestamp — audio/video timestampAppend ?chat={chat_opaque_id} to the workspace storage URL:
https://{domain}.fast.io/workspace/{folder_name}/storage/root?chat={chat_id}
Shares support AI chat with identical capabilities. All workspace AI endpoints have share equivalents at /share/{share_id}/ai/chat/.... Use the share-ai-* tools for share-scoped AI conversations.
Generate temporary markdown-formatted download URLs for files that can be pasted into external AI tools (ChatGPT, Claude, etc.). Use ai-share-generate for workspace files or share-ai-share-generate for share files. URLs expire after 5 minutes. Limits: 25 files maximum, 50 MB per file, 100 MB total.
Organizations, workspaces, and shares are all identified by 19-digit numeric profile IDs. These appear throughout the tool parameters as workspace_id, share_id, org_id, profile_id, and member_id.
Most endpoints also accept custom names as identifiers:
| Profile Type | Numeric ID | Custom Name |
|---|---|---|
| Workspace | 19-digit ID | Folder name (e.g., my-project) |
| Share | 19-digit ID | URL name (e.g., q4-financials) |
| Organization | 19-digit ID | Domain name (e.g., acme) |
| User | 19-digit ID | Email address (e.g., user@example.com) |
QuickShares are temporary public download links for individual files in workspaces (not available for shares). They can be accessed without authentication. Expires in seconds from creation (default 10,800 = 3 hours, max 86,400 = 24 hours). Max file size: 1 GB. Each quickshare has an opaque identifier used to retrieve metadata and download the file.
Files uploaded to Fast.io get automatic preview generation. When humans open a share or workspace, they see the content immediately -- no "download and open in another app" friction.
Supported preview formats:
Use workspace-preview-url or share-preview-url to generate preview URLs. Use workspace-transform or share-transform for image resize, crop, and format conversion.
Agent use case: Your generated PDF report does not just appear as a download link. The human sees it rendered inline, can flip through pages, zoom in, and comment on specific sections -- all without leaving the browser.
Humans and agents can leave feedback directly on files, anchored to specific content using the reference parameter:
Comments use JSON request bodies (Content-Type: application/json), unlike most other endpoints which use form-encoded data.
Listing comments: Use comments-list for per-file comments and comments-list-all for all comments across a workspace or share. Both support sort, limit (2-200), offset, include_deleted, reference_type filter, and include_total.
Adding comments: Use comments-add with profile_type, profile_id, node_id, and text. Optionally include parent_comment_id for replies and reference to anchor to a specific position.
Deleting comments: comments-delete is recursive -- deleting a parent also removes all replies. comments-bulk-delete is NOT recursive -- replies to deleted comments are preserved.
Linking users to comments: The preview URL opens the comments sidebar automatically. Deep link query parameters let you target a specific comment or position:
| Parameter | Format | Purpose |
|---|---|---|
?comment={id} | Comment opaque ID | Scrolls to and highlights a specific comment for 2 seconds |
?t={seconds} | e.g. ?t=45.5 | Seeks to timestamp for audio/video comments |
?p={pageNum} | e.g. ?p=3 | Navigates to page for PDF comments |
Workspace: https://{org.domain}.fast.io/workspace/{folder_name}/preview/{file_opaque_id}?comment={comment_id}
Share: https://go.fast.io/shared/{custom_name}/{title-slug}/preview/{file_opaque_id}?comment={comment_id}
Parameters can be combined -- e.g. ?comment={id}&t=45.5 to deep link to a video comment at a specific timestamp. In shares, the comments sidebar only opens if the share has comments enabled.
Agent use case: You generate a design mockup. The human comments "Change the header color" on a specific region of the image. You read the comment, see exactly what region they are referring to via the reference.region coordinates, and regenerate.
Agents can import files directly from URLs without downloading them locally first. Fast.io's server fetches the file, processes it, and adds it to your workspace or share.
Use web-upload with the source URL, target profile, and parent node ID. Use web-upload-status to check progress and web-upload-list to list active import jobs.
Security note: The web-upload tool instructs the Fast.io cloud server to fetch the URL -- not the agent's local environment. The Fast.io server is a public cloud service with no access to your local network, internal systems, or private infrastructure. It can only reach publicly accessible URLs and supported OAuth-authenticated cloud storage providers. This is functionally equivalent to the agent downloading a file and re-uploading it; the same data is transferred, just more efficiently since the server handles it directly. No internal or private data is exposed beyond what the agent could already access through its own network requests.
Agent use case: A user says "Add this Google Doc to the project." You call web-upload with the URL. Fast.io downloads it server-side, generates previews, indexes it for AI, and it appears in the workspace. No local I/O.
Fast.io uses WebSockets for instant updates across all connected clients:
Use realtime-auth to generate JWTs for YJS collaborative editing rooms and websocket-auth for WebSocket event channels.
The primary way agents deliver value: build something, then give it to a human. Also the recommended action when the agent plan runs out of credits and API calls start returning 402 Payment Required -- transfer the org to a human who can upgrade to a paid plan.
IMPORTANT: Account type restriction. The transfer/claim workflow (org-transfer-token-create, org-transfer-token-list, org-transfer-token-delete, org-transfer-claim) is only available when the agent created an agent account (via auth-signup) and that agent account owns the org. If the agent is signed in with a human account (via auth-signin), the transfer/claim API cannot be used. Human-owned orgs must be upgraded directly by the human through the Fast.io dashboard.
The flow:
auth-signup and an org with org-create, sets up workspaces with org-create-workspace, uploads files, configures sharesorg-transfer-token-createhttps://go.fast.io/claim?token=<token>When to transfer:
Managing transfer tokens:
org-transfer-token-list -- check for existing pending tokens before creating new onesorg-transfer-token-delete -- revoke a token if the transfer is no longer neededorg-transfer-claim -- claim an org using a token (used by the receiving human's agent)What happens after transfer:
Agent use case: A user says "Set up a project workspace for my team." You create the org, build out the workspace structure, upload templates, configure shares for client deliverables, invite team members -- then transfer ownership. The human walks into a fully configured platform. You stay on as admin to keep managing things.
402 Payment Required use case (agent account): While working, the agent hits credit limits. Call org-transfer-token-create, send the claim URL to the human, and explain they can upgrade to continue. The agent keeps admin access and resumes work once the human upgrades.
402 Payment Required use case (human account): The agent cannot transfer the org. Instead, inform the user that their org has run out of credits and they need to upgrade their billing plan. Direct them to the Fast.io dashboard or use org-billing-create to update to a paid plan.
Several tools use permission parameters with specific allowed values. Use these exact strings when calling the tools.
org-create)| Parameter | Allowed Values | Default |
|---|---|---|
perm_member_manage | Owner only, Admin or above, Member or above | Member or above |
industry | unspecified, technology, healthcare, financial, education, manufacturing, construction, professional, media, retail, real_estate, logistics, energy, automotive, agriculture, pharmaceutical, legal, government, non_profit, insurance, telecommunications, research, entertainment, architecture, consulting, marketing | unspecified |
background_mode | stretched, fixed | stretched |
org-create-workspace) and Update (workspace-update)| Parameter | Allowed Values | Default |
|---|---|---|
perm_join | Only Org Owners, Admin or above, Member or above | Member or above |
perm_member_manage | Admin or above, Member or above | Member or above |
share-create)| Parameter | Allowed Values | Default |
|---|---|---|
type | send, receive, exchange | exchange |
storage_mode | independent, workspace_folder | independent |
access_options | Only members of the Share or Workspace, Members of the Share, Workspace or Org, Anyone with a registered account, Anyone with the link | Only members of the Share or Workspace |
invite | owners, guests | owners |
notify | never, notify_on_file_received, notify_on_file_sent_or_received | never |
display_type | list, grid | grid |
intelligence | true, false | false |
comments_enabled | true, false | true |
download_enabled | true, false | true |
guest_chat_enabled | true, false | false |
workspace_style | true, false | true |
background_image | 0-128 | 0 |
Share constraints:
Anyone with the link access -- this option is only available for Send shares.password parameter) is only allowed when access_options is Anyone with the link.expires parameter in MySQL format YYYY-MM-DD HH:MM:SS) is not allowed on workspace_folder shares.custom_name must be 10-100 characters, alphanumeric + unicode.title (or name) must be 2-80 characters.accent_color, background_color1, background_color2) accept JSON strings.create_folder creates a new workspace folder for the share when used with storage_mode='workspace_folder'.The agent plan is a free tier designed for AI agents. No credit card, no trial period, no expiration. Enough resources to build and demonstrate value, with room to grow when the org transfers to a human on a paid plan.
| Resource | Included |
|---|---|
| Price | $0 -- no credit card, no trial period, no expiration |
| Storage | 50 GB |
| Max file size | 1 GB |
| Monthly credits | 5,000 (resets every 30 days) |
| Workspaces | 5 |
| Shares | 50 |
| Members per workspace | 5 |
| Share invitations | 10 per share |
| Account auto-deletion | Never |
All platform activity consumes credits from the monthly 5,000 allowance:
| Resource | Cost |
|---|---|
| Storage | 100 credits/GB |
| Bandwidth | 212 credits/GB |
| AI chat tokens | 1 credit per 100 tokens |
| Document pages ingested | 10 credits/page |
| Video ingested | 5 credits/second |
| Audio ingested | 0.5 credits/second |
| Images ingested | 5 credits/image |
| File conversions | 25 credits/conversion |
When credits run out, the org enters a reduced-capability state and API calls return 402 Payment Required. The org is never deleted. Use org-limits to check current credit usage and remaining balance.
When you hit 402 or run low on credits:
auth-signup): Transfer the org to the human. Call org-transfer-token-create to generate a transfer token, then send the human the claim URL: https://go.fast.io/claim?token=<token>. Once they claim the org they can upgrade to a paid plan with unlimited credits. You retain admin access and can resume work immediately after the upgrade. This is the expected workflow -- agents build on the free plan, then hand off to humans who pay when they are ready.auth-signin): You cannot use the transfer/claim API. Tell the user they need to upgrade the org's billing plan directly. They can do this from the Fast.io dashboard or by calling org-billing-create to update their subscription to a paid plan.Once an agent transfers an org to a human, the human gets a free plan (credit-based, no trial period) and can upgrade:
| Feature | Agent (Free) | Free (Human) | Pro | Business |
|---|---|---|---|---|
| Monthly credits | 5,000 | 5,000 | Unlimited | Unlimited |
| Storage | 50 GB | 50 GB | 1 TB | 5 TB |
| Max file size | 1 GB | 1 GB | 25 GB | 50 GB |
| Workspaces | 5 | 5 | 10 | 1,000 |
| Shares | 50 | 50 | 1,000 | 50,000 |
The transfer flow is the primary way agents deliver value: set everything up on the free agent plan, then hand it off. The human upgrades when they are ready, and the agent retains admin access to keep managing things.
The 258 tools are organized into 20 modules. Each module covers a specific area of the Fast.io platform.
Tools prefixed with auth-* and oauth-*. Covers sign-in, sign-up, two-factor authentication setup and verification, API key management, and OAuth session management. This is always the starting point for any agent interaction.
Tools prefixed with user-*. Covers retrieving and updating the current user profile, searching for other users, managing invitations, uploading and deleting user assets (profile photos), checking account eligibility, and listing shares the user belongs to.
Tools prefixed with org-*, orgs-*, and list-orgs. Covers organization CRUD, member management, billing and subscription operations, workspace creation, invitation workflows, asset management (upload, delete), and organization discovery.
Tools prefixed with workspace-* and list-workspaces. Covers browsing and managing files and folders within workspace storage: listing, creating folders, moving, copying, deleting, renaming, searching, managing trash, creating notes, adding files from uploads, adding share links, transferring nodes between workspaces, and quickshare management.
Tools for workspace-level settings and lifecycle: updating workspace settings, deleting workspaces, archiving and unarchiving, listing and importing shares, managing workspace assets (upload, delete), and workspace discovery.
Tools prefixed with workspace-member-*, workspace-invitation-*, and workspace join/leave. Covers adding and removing members, updating roles, transferring ownership, self-join flows, and invitation management.
Tools for share-level storage operations and share CRUD: listing shares, creating/updating/deleting shares, browsing share storage, managing share members, creating folders, copying, moving, deleting, purging, restoring, renaming, searching, adding files from uploads, transferring nodes, and creating quickshares.
Tools for share lifecycle and discovery: public details, archiving, password authentication, asset management (upload, delete), member CRUD (leave, details, update, transfer ownership), invitation management, join flows, and share name availability checks.
Tools prefixed with workspace-download-*, share-download-*, and quickshare-details. Generate download URLs and ZIP archive URLs for workspace files, share files, and quickshare links. Important: MCP tools cannot stream binary data. These tools return URLs that can be opened in a browser or passed to download utilities.
Tools for generating preview URLs: workspace-preview-url, share-preview-url, workspace-transform, share-transform. Supports thumbnails, PDFs, images, video (HLS), audio, and spreadsheet previews. Transform tools support image resize, crop, and format conversion.
Tools prefixed with upload-* and web-upload*. Includes upload-text-file for single-step text file uploads and the full chunked upload lifecycle (create session, upload chunks as plain text, staged binary blobs, or legacy base64, finalize, check status, cancel), web imports from external URLs, upload limits and file extension restrictions, and session management. Binary chunk data can be staged via POST /blob to avoid base64 overhead.
Tools prefixed with comments-* and comment-*. Comments are scoped to {entity_type}/{parent_id}/{node_id} where entity_type is workspace or share, parent_id is the 19-digit profile ID, and node_id is the storage node opaque ID. Comments use JSON request bodies. Covers listing comments on files (per-node and profile-wide with sort/limit/offset/filter params), adding comments with optional reference anchoring (image regions, video/audio timestamps, PDF pages with text selection), single-level threaded replies, recursive single delete, non-recursive bulk delete, getting comment details, and emoji reactions (one per user per comment).
Tools prefixed with ai-*. Covers AI-powered chat with RAG in workspaces: creating chats, sending messages, reading AI responses (with polling), listing and managing chats, publishing private chats, generating AI share markdown, and tracking AI token usage.
Tools prefixed with share-ai-*. The same AI chat capabilities as workspace AI but scoped to shares. Includes auto-title generation, chat CRUD, message send/read with polling, chat publishing, and AI share markdown generation.
Tools prefixed with metadata-* and workspace-metadata-*. Covers metadata template management (create, update, delete, list, settings), metadata extraction from files using templates, metadata CRUD on storage nodes, and saved metadata views.
Tools prefixed with workspace-versions-* and share-versions-*. List file version history and restore files to previous versions in both workspaces and shares.
Tools prefixed with workspace-lock-* and share-lock-*. Acquire, check, and release exclusive file locks in workspaces and shares to prevent concurrent edits.
Tools prefixed with events-* and event-*. Search the audit/event log with rich filtering, get AI-powered summaries of activity, and retrieve full details for individual events. Note: Events use offset-based pagination (limit 1-250, offset), not cursor-based. Only one profile filter at a time (workspace_id OR share_id OR org_id OR user_id).
Events give agents a real-time audit trail of everything that happens across an organization. Instead of scanning entire workspaces to detect what changed, an agent can query the events feed to see exactly which files were uploaded, modified, renamed, or deleted -- and by whom, and when. This makes it practical to build workflows that react to changes: processing a document the moment it arrives, flagging unexpected permission changes, or generating a daily summary of activity for a human operator.
The activity log is also the most efficient way for an agent to stay in sync with a workspace over time. Rather than periodically listing every file and comparing against a previous snapshot, the agent can check events since its last poll to get a precise diff. This is especially valuable in large workspaces where full directory listings are expensive. Events cover not just file operations but also membership changes, share activity, and settings updates -- so an agent can monitor the full picture of what's happening in an organization without constant brute-force polling.
Tools for real-time collaboration: realtime-auth generates JWTs for YJS collaborative editing rooms, realtime-validate validates realtime tokens, and websocket-auth generates JWTs for WebSocket event channels.
Tools for health checks and infrastructure: system-status and ping (both unauthenticated), activity-list (recent events), activity-poll (long-poll change detection), and webhook management (list, create, delete).
See Choosing the Right Approach in section 2 for which option fits your scenario.
Option 1 -- Autonomous agent (new account):
auth-email-check with the desired email to verify availability.auth-signup with first_name, last_name, email, and password -- registers as an agent account (agent=true is sent automatically) and signs in immediately.auth-email-verify with email -- sends a verification code. Then auth-email-verify with email and email_token -- validates the code. Required before using most endpoints.org-create to create a new org on the agent plan, or list-orgs to check existing orgs.Option 2 -- Assisting a human (API key):
https://go.fast.io/settings/api-keys and provides it to the agent.auth-set-api-key with the API key. The key is validated against the API and stored in the session -- all subsequent tool calls are authenticated automatically. No account creation needed.list-orgs and orgs-external to discover all available organizations (see Org Discovery).Option 3 -- Agent invited to a human's org:
auth-signup (same as Option 1).org-invite-member or workspace-member-add.user-invitations-accept-all.list-orgs and orgs-external to discover all available orgs (see Org Discovery). If the human only invited you to a workspace (not the org), it will only appear via orgs-external.Returning users:
auth-signin with email and password.two_factor_required: true, call auth-2fa-verify with the 2FA code.list-orgs and orgs-external to discover all available organizations (see Org Discovery).list-orgs and orgs-external -- discover all available organizations (see Org Discovery). Note the org_id values.org-list-workspaces with org_id -- get workspaces in the organization. Note the workspace_id values.workspace-storage-list with workspace_id and node_id: "root" -- browse the root folder. Note the node_id values for files and subfolders.workspace-storage-details with workspace_id and node_id -- get full details for a specific file (name, size, type, versions).workspace-download-url with workspace_id and node_id -- get a temporary download URL with an embedded token. Return this URL to the user.Text files (recommended): Use upload-text-file with profile_type: "workspace", profile_id, parent_node_id, filename, and content (plain text). This single tool creates the session, uploads, finalizes, and polls until stored — returns new_file_id on success. Use this for code, markdown, CSV, JSON, config files, and any other text content.
Binary or large files (chunked flow):
upload-create-session with profile_type: "workspace", profile_id (the workspace ID), parent_node_id (target folder or "root"), filename, and filesize in bytes. Returns an upload_id.upload-chunk with upload_id, chunk_number (1-indexed), and chunk data. Three options for passing data (provide exactly one):
content — for text (strings, code, JSON, etc.). Do NOT use data for text.blob_ref — preferred for binary. First POST raw bytes to /blob (with Mcp-Session-Id header, Content-Type: application/octet-stream). The server returns { blob_id, size }. Then pass that blob_id as blob_ref. Avoids base64 overhead entirely. Blobs expire after 5 minutes and are consumed (deleted) on use.data — legacy base64-encoded binary. Still works but adds ~33% size overhead.
Repeat for each chunk. Wait for each chunk to return success before sending the next.upload-finalize with upload_id -- triggers file assembly and polls until stored. Returns the final session state with status: "stored" or "complete" on success (including new_file_id), or throws on assembly failure. The file is automatically added to the target workspace and folder specified in step 1 -- no separate add-file call is needed.Note: workspace-add-file is only needed if you want to link the upload to a different location than the one specified during session creation.
Use this when you have a file URL (HTTP/HTTPS, Google Drive, OneDrive, Box, Dropbox) and want to add it to a workspace without downloading locally.
web-upload with url (the source URL), profile_type: "workspace", profile_id (the workspace ID), and parent_node_id (target folder or "root"). Returns a job_id.web-upload-status with job_id -- check import progress. The server downloads the file, scans it, generates previews, and indexes it for AI (if intelligence is enabled).Create a branded, professional data room for outbound file delivery. This replaces raw download links, email attachments, and S3 presigned URLs.
share-create with workspace_id, name, and type: "send" -- creates a Send share. Returns a share_id.share-update with share_id to configure:
password -- require a password for accessexpiry_date -- auto-expire the share after a set periodaccess_level -- Members Only, Org Members, Registered Users, or Publicallow_downloads -- enable or disable file downloadsbackground_color, accent_color, gradient_colorpost_download_message and post_download_url -- show a message after downloadshare-member-add with share_id and email_or_user_id -- adds the recipient. An invitation is sent if they do not have a Fast.io account.share-asset-upload with share_id to add a logo or background image for branding.Create a Receive share so humans can upload files directly to you -- no email attachments, no cloud drive links.
share-create with workspace_id, name (e.g., "Upload your tax documents here"), and type: "receive". Returns a share_id.share-update with share_id to set access level, expiration, and branding as needed.share-member-add with share_id and email_or_user_id to invite the uploader.ai-chat-create scoped to the receive share's folder to ask questions like "Are all required forms present?"Create an intelligent workspace that auto-indexes all content for RAG queries.
org-create-workspace with org_id and name. Intelligence is enabled by default.ai-chat-create with workspace_id, query_text, type: "chat_with_files", and folders_scope (comma-separated nodeId:depth pairs) to query across folders or the entire workspace.ai-message-read with workspace_id, chat_id, and message_id -- polls until the AI response is complete. Returns response_text and citations pointing to specific files, pages, and snippets.workspace-search with workspace_id and a query string for semantic search -- find files by meaning, not just filename.Two modes depending on whether intelligence is enabled on the workspace.
With intelligence (persistent index):
ai-chat-create with workspace_id, query_text, type: "chat_with_files", and either files_scope (comma-separated nodeId:versionId pairs) or folders_scope (comma-separated nodeId:depth pairs, depth range 1-10). Important: files_scope and files_attach are mutually exclusive — sending both will error. Returns chat_id and message_id.ai-message-read with workspace_id, chat_id, and message_id -- polls the API up to 15 times (2-second intervals, approximately 30 seconds) until the AI response is complete. Returns response_text and citations. Tip: If the built-in polling window expires, use activity-poll with the workspace ID instead of calling ai-message-read in a loop — see the Activity Polling section above.ai-message-send with workspace_id, chat_id, and query_text for follow-up questions. Returns a new message_id.ai-message-read again with the new message_id to get the follow-up response.Without intelligence (file attachments):
ai-chat-create with workspace_id, query_text, type: "chat_with_files", and files_attach pointing to specific files (comma-separated nodeId:versionId, max 10 files). Files must have a ready preview. The AI reads attached files directly without persistent indexing.ai-message-read to get the response. No ingestion credit cost -- only chat token credits are consumed.The full agent-to-human handoff workflow. This is the primary way agents deliver value on Fast.io.
org-create -- creates a new org on the agent billing plan. The agent becomes owner. An agent-plan subscription (free, 50 GB, 5,000 credits/month) is created automatically.org-create-workspace with org_id and name -- create workspaces for each project area.workspace-create-folder to build out folder structure (templates, deliverables, reference docs, etc.).share-create with type: "send" for client deliverables, type: "receive" for intake/collection.share-update to configure branding, passwords, expiration, and access levels on each share.org-invite-member or workspace-member-add to invite team members.org-transfer-token-create with org_id -- generates a transfer token valid for 72 hours. Send the claim URL (https://go.fast.io/claim?token=<token>) to the human.org-billing-plans -- list all available billing plans with pricing and features.org-billing-create with org_id and optionally billing_plan -- create or update a subscription. For new subscriptions, this creates a Stripe Setup Intent.org-billing-details with org_id -- check the current subscription status, Stripe customer info, and payment details.org-limits with org_id -- check credit usage against plan limits, including storage, transfer, AI tokens, and billing period info.Profile IDs (org, workspace, share, user) are 19-digit numeric strings. Most endpoints also accept custom names as identifiers -- workspace folder names, share URL names, org domain names, or user email addresses. Both formats are interchangeable in URL path parameters.
All other IDs (node IDs, upload IDs, chat IDs, comment IDs, invitation IDs, etc.) are 30-character alphanumeric opaque IDs (displayed with hyphens). Do not apply numeric validation to these.
Two pagination styles are used depending on the endpoint:
Cursor-based (storage list endpoints): sort_by, sort_dir, page_size, and cursor. The response includes a next_cursor value when more results are available. Pass this cursor in the next call to retrieve the next page. Page sizes are typically 100, 250, or 500. Used by: workspace-storage-list, share-storage-list.
Limit/offset (all other list endpoints): limit (1-500, default 100) and offset (default 0). Used by: list-orgs, org-members, org-list-workspaces, org-list-shares, org-billing-members, orgs-all, orgs-external, list-shares, share-members-list, share-search, list-workspaces, workspace-search, workspace-members, workspace-list-shares, user-list-shares.
MCP tools return download URLs -- they never stream binary content directly. Download tools (workspace-download-url, share-download-url, quickshare-details) call the /requestread/ endpoint to obtain a temporary token, then construct a full download URL. The agent should return these URLs to the user or pass them to a download utility.
ZIP download tools (workspace-download-zip, share-download-zip) return the URL along with the required Authorization header value.
For binary chunk uploads, the server provides a sidecar POST /blob endpoint that accepts raw binary data outside the JSON-RPC pipe. This avoids the ~33% size overhead and CPU cost of base64 encoding.
Flow:
POST /blob with headers Mcp-Session-Id: <session_id> and Content-Type: application/octet-stream. Send raw binary bytes as the request body. The server returns { "blob_id": "<uuid>", "size": <bytes> } (HTTP 201).upload-chunk with blob_ref: "<blob_id>" instead of data. The server retrieves the staged bytes and uploads them to the Fast.io API.Constraints:
?transport=sse to the /blob URL.content parameter (for text) and data parameter (for base64) remain available. blob_ref is the preferred method for binary data.Three mechanisms for detecting changes, listed from most to least preferred:
activity-poll (long-poll) — The server holds the connection for up to 95 seconds and returns immediately when something changes. Returns activity keys (e.g. ai_chat:{chatId}, storage, members) and a lastactivity timestamp for the next poll. Use this for any "wait for something to happen" scenario, including AI chat completion.websocket-auth → WebSocket — Generate a JWT with websocket-auth, then connect to the WebSocket endpoint for real-time push events. Best for live UIs.activity-list (manual fallback) — Retrieves recent activity events on demand. Use when you need a one-time snapshot rather than continuous monitoring.Why this matters: Do not poll detail endpoints (like ai-message-read) in tight loops. Instead, use activity-poll to detect when something has changed, then fetch the details once.
ai-message-read and share-ai-message-read implement built-in polling (up to 15 attempts, 2-second intervals). If the response is still processing after that window, use activity-poll with the workspace or share ID instead of calling the read tool in a loop:
activity-poll with entity_id set to the workspace/share ID.ai_chat:{chatId} key matching your chat, call ai-message-read once to get the completed response.ai-chat-create) and note the server_date field in the response.activity-poll with entity_id (workspace or share ID) and lastactivity set to the server_date value.ai-message-read, workspace-storage-list).lastactivity value from the poll response (or the latest server_date) for the next activity-poll call. Repeat as needed.delete (e.g., workspace-delete, share-delete-node) moves items to the trash. They are recoverable.restore (e.g., workspace-restore, share-restore) recovers items from the trash.purge (e.g., workspace-purge, share-purge) permanently and irreversibly deletes items from the trash.Always confirm with the user before calling purge operations.
Storage nodes can be files, folders, notes, or links. The type is indicated in the storage details response. Notes are markdown files created with workspace-create-note and updated with workspace-update-note. Links are share reference nodes created with workspace-add-link.
Failed API calls throw errors with two fields: code (unique numeric error ID) and text (human-readable description). Tools surface these as error text in the MCP response. Common HTTP status codes include 401 (unauthorized), 403 (forbidden), 404 (not found), and 429 (rate limited).
The auth token, user ID, email, and token expiry are persisted in the server session. There is no need to pass tokens between tool calls. The session survives across multiple tool invocations within the same MCP connection.
MCP tools manage data via the API, but humans access Fast.io through a web browser. You must construct real, clickable URLs and include them in your responses whenever you create or reference a workspace, share, or transfer. The human cannot see API responses directly -- the URL you provide is how they get to their content. Build the URL by substituting values from API responses into these patterns:
Organization domain values become subdomains: "acme" → https://acme.fast.io/. The base domain go.fast.io handles public routes that do not require org context.
| What the human needs | URL pattern |
|---|---|
| Workspace root | https://{domain}.fast.io/workspace/{folder_name}/storage/root |
| Specific folder | https://{domain}.fast.io/workspace/{folder_name}/storage/{node_id} |
| File preview | https://{domain}.fast.io/workspace/{folder_name}/preview/{node_id} |
| File with specific comment | https://{domain}.fast.io/workspace/{folder_name}/preview/{node_id}?comment={comment_id} |
| File at video/audio time | https://{domain}.fast.io/workspace/{folder_name}/preview/{node_id}?t={seconds} |
| File at PDF page | https://{domain}.fast.io/workspace/{folder_name}/preview/{node_id}?p={page_num} |
| AI chat in workspace | https://{domain}.fast.io/workspace/{folder_name}/storage/root?chat={chat_id} |
| Note in workspace | https://{domain}.fast.io/workspace/{folder_name}/storage/root?note={note_id} |
| Note preview | https://{domain}.fast.io/workspace/{folder_name}/preview/{note_id} |
| Browse workspaces | https://{domain}.fast.io/browse-workspaces |
| Edit share settings | https://{domain}.fast.io/workspace/{folder_name}/share/{custom_name} |
| Org settings | https://{domain}.fast.io/settings |
| Billing | https://{domain}.fast.io/settings/billing |
| What the human needs | URL pattern |
|---|---|
| Public share | https://go.fast.io/shared/{custom_name}/{title-slug} |
| Org-branded share | https://{domain}.fast.io/shared/{custom_name}/{title-slug} |
| File in share | https://go.fast.io/shared/{custom_name}/{title-slug}/preview/{node_id} |
| File in share with comment | https://go.fast.io/shared/{custom_name}/{title-slug}/preview/{node_id}?comment={comment_id} |
| QuickShare | https://go.fast.io/quickshare/{quickshare_id} |
| Claim org transfer | https://go.fast.io/claim?token={transfer_token} |
| Onboarding | https://go.fast.io/onboarding or https://go.fast.io/onboarding?orgId={org_id}&orgDomain={domain} |
| Value | API source |
|---|---|
domain | org-create or org-details response |
folder_name | org-create-workspace or workspace-details response |
node_id | workspace-storage-list, workspace-create-folder, workspace-add-file response |
custom_name | share-create or share-details response (the {title-slug} is cosmetic -- the share resolves on custom_name alone) |
quickshare_id | quickshare-create response |
transfer_token | org-transfer-token-create response |
chat_id | ai-chat-create or ai-chat-list response |
note_id | workspace-create-note or workspace-storage-list response (node opaque ID) |
comment_id | comments-add or comments-list response |
org_id | org-create or list-orgs response |
Always provide URLs to the human in these situations:
https://acme.fast.io/workspace/q4-reports/storage/roothttps://go.fast.io/shared/q4-financials/Q4-Financial-Report -- this is the branded page the human (or their recipients) will open.https://go.fast.io/claim?token=abc123 -- this is the only way the human can claim ownership.Important: The domain is the org's domain string (e.g. acme), not the numeric org ID. The folder_name is the workspace's folder name string (e.g. q4-reports), not the numeric workspace ID. Both are returned by their respective API tools.
The following tools work without a session: system-status, ping, quickshare-details, auth-signin, auth-signup, auth-set-api-key, auth-email-check, auth-password-reset-request, and auth-password-reset.
All 258 tools organized by module. Each entry shows the tool name and its description as registered in the MCP server.
content or base64-encoded content_base64 (not both).member: true). Returns member orgs with subscription status, user permission, and plan info. Non-admin members only see orgs with active subscriptions. Does not include external orgs -- use orgs-external for those.https://go.fast.io/claim?token=<token> to a human. Use when handing off an org or when hitting 402 Payment Required on the agent plan. Requires owner role.content or base64-encoded file_base64 (not both). Requires admin or owner role.member: false) -- orgs the user can access only through workspace membership, not as a direct org member. Common when a human invites an agent to a workspace without inviting them to the org. See Internal vs External Orgs in the Organizations section.content or base64-encoded file_data (not both).email_or_user_id.email_or_user_id.content or base64-encoded data (not both).content for text/strings, blob_ref for binary data staged via POST /blob (preferred — avoids base64 overhead), or data for legacy base64-encoded binary. Provide exactly one.wait parameter (in milliseconds, 0 = immediate).All comment endpoints use the path pattern /comments/{entity_type}/{parent_id}/ or /comments/{entity_type}/{parent_id}/{node_id}/ where entity_type is workspace or share, parent_id is the 19-digit profile ID, and node_id is the file's opaque ID.
created/-created), limit (2-200), offset, include_deleted, reference_type filter, include_total.