MCP Server

What the assistant can do

Twenty tools for everyday use, across meetings, action items, knowledge, memory and workspace navigation. Each one is scoped, and each one runs as you.

Read tools are marked read, tools that change something are marked write. Nothing here deletes data outright. The closest is dismissing or snoozing an action item, both reversible.

Meetings

Scoped to meetings you can already see: everything shared with your workspace, plus your own private recordings. Never anyone else's private meetings.

Tool	What it does
`find_meetings`read	Search recorded meetings by title (semantic and literal), by participant name or email, and by date range. Returns title, date, platform, participants and a short AI summary. Up to 50 results.
`get_transcript`read	Read one meeting's transcript as speaker-attributed segments with timestamps. Paginated, up to 2,000 segments per call, good for exact quotes.
`download_transcript`read	Get the entire transcript in one go as a plain-text file attachment, with a header of title, date and participants. Useful when you want to save or forward it.

Action items

Your own items, in your current workspace. Reads default to open work: completed, dismissed and cancelled items are hidden unless you ask for a status explicitly.

Tool	What it does
`list_action_items`read	List items with optional filters on status, priority, free text and date range.
`get_action_item`read	Full detail for one item, including the source excerpts it was extracted from and the ordered steps of its current plan.
`create_action_item`write	Create a new item with title, description, priority, due date and instructions. Lands as Pending, labelled “Created via MCP”.
`update_action_item`write	Change any subset of those fields. Omitted fields are left alone; an empty update is rejected rather than silently doing nothing.
`mark_action_item_done`write	Close an item out.
`dismiss_action_item`write	Dismiss an item you don't intend to act on.
`snooze_action_item`write	Push an item out to a date.
`restore_action_item`write	Bring a dismissed or snoozed item back.

These tools manage action items. They do not run plans: execution stays in the Revo app, where you approve it.

Ask Revo

Tool	What it does
`ask_revo`agent	Put a natural-language question to Revo's own agent, which runs over your workspace with its full toolset: workspace data, your connected integrations, and the web. Returns an answer plus a `sessionId`; pass that back on the next call to continue the same conversation.

This is the deepest tool and the one to reach for when a question spans systems: “Check Slack and the last Acme meeting. Did we ever send them the revised SOW?” It is also the slowest. Revo streams progress updates every five seconds while it works so your client doesn't time out, and it stops on its own after 20 tool calls or 15 minutes. Cancelling in your client genuinely stops the run on Revo's side.

Team memory, the part that compounds

There are two ways an assistant can have context. It can be given it: a project folder, uploaded files, a system prompt someone wrote, which is precise on the day it's assembled and quietly wrong a month later, because keeping it true is somebody's unpaid job. Or it can observe the work itself. Revo does the second.

Your team memory is assembled continuously from meetings, chat channels, email and connected tools with nobody maintaining it: the people, customers, projects and decisions your organization actually runs on, plus the relationships between them. One person stays one entity however their name is written across a dozen systems, and every connection carries a count of how many independent sources assert it, deduplicated, so a fact repeated in one long thread doesn't outrank one corroborated across a meeting, an email and a ticket. The context becomes the durable asset and the model becomes interchangeable.

What that changes at the point of use is concrete:

You stop briefing the assistant. “Draft the follow-up from Tuesday” is enough, because who was in the room, what was agreed and what shipped since are already known. No attachments, no re-explaining your own job.
It retrieves instead of ingesting. Rather than pushing whole documents through the context window and paying for every irrelevant page, Revo pulls the specific facts that bear on the question, which is both cheaper and sharper, since precision beats volume once a model has enough to work with.
It tells you things you didn't know to ask. The most valuable answers tend to be the adjacent ones: that another team hit the same problem last month, that a decision you're about to relitigate was already made. No individual can hold the whole organization in their head. This can.
It survives your tooling choices. Memory lives outside the model, so switching assistant, provider or price tier next quarter costs you nothing. Given how fast this market moves, that is not a small property.
It gets better the longer it runs. Every meeting and thread deepens it. The teams that see the most value are simply the ones that started earliest, and a new joiner inherits all of it on day one instead of spending a quarter asking around.

Through MCP, your assistant reaches two layers of this: your own memories, which are private to you, and the team knowledge graph, filtered to exactly what you're permitted to see. Private meetings and email stay private: they inform your work and no one else's.

Tool	What it does
`search_brain`readearly access	In early access, request access. Ask the team knowledge graph a question in plain language and get back evidence rather than assertions: the snippets that matched, each with its source and deep link, the entities they mention, and the recorded relationships between those entities. Revo will only state a connection it can point at a source for. Matching transcript slices come back too, so an answer about a decision arrives with the moment it was made. Everything is filtered to your own visibility before it leaves the server. Until the graph is switched on for your workspace the tool stays listed but replies “the knowledge graph isn't enabled for this workspace yet”, so ask your Revo contact to enable it.
`add_document`write	Add a document to your workspace knowledge base, either text (Markdown or HTML) or a binary file uploaded inline as base64, such as a PDF, image or spreadsheet the assistant just generated.
`list_my_memories`read	List the durable facts Revo has learned about you: preferences, working style, context. Yours only.
`add_memory`write	Save a new one, optionally with a category and an expiry in days. It lands in the same store Revo itself reads, so it shapes Revo's answers in the app too.
`push_conversation`write	Push a finished conversation from this or another AI assistant into Revo, so what you worked out in a chat becomes part of what Revo knows. Idempotent on a client-side session id, so pushing twice is safe. What Revo learns from it feeds your memories; the knowledge-graph half depends on the same rollout as `search_brain`.

Usage and workspaces

Tool	What it does
`get_my_usage`read	Your own AI token usage and your workspace's aggregate usage over a window: totals, cost, per-model and per-feature breakdowns. Regular members see the workspace total; only workspace admins additionally see the per-teammate breakdown.
`list_my_workspaces`read	List the workspaces you belong to, your role in each, and which is currently active.
`switch_workspace`write	Change which workspace is active. This is the same active-workspace setting the Revo web app uses, so it switches there too, and it takes effect from the assistant's next call, not the current one.

Revo staff tools

A further nineteen tools exist for Revo's own support and operations staff (revo_admin): workspace lookup, billing changes, usage reporting, the integration catalogue, signup blocklists and memory debugging. They are the only tools that can address a workspace other than the caller's own.

They are off for everyone by default. Access is gated by a feature flag targeting named staff email addresses; if you are not on that list, these tools are not merely refused, they are absent from the tool list your assistant receives, so it cannot know they exist or attempt to call them. Section 5 covers the mechanism.