Plainpaper agent tools: the MCP tool reference

Every tool Plainpaper's MCP server offers a connected agent, in plain language: all 54 of them, what each one does, and where the approval gates sit. Generated from the server's source code, so the list stays complete as tools ship.

How to read this page

You never call these tools yourself. When your agent connects to mcp.plainpaper.io/mcp/ (see Connect your agent), it discovers all 54 automatically and picks the right one for whatever you ask in plain language. This page exists so you can see exactly what a connected agent can do on your boards, and what it can't.

Two things are deliberately missing from the list. There is no tool that sends an email, publishes an ad, or spends money: when work leaves Plainpaper, your agent performs the send through that platform's own connector, after you approve it on the board. And there is no tool that deletes a board or a card; the one structural delete an agent can reach, removing a phase, exists only as a proposal a human clicks to approve.

Kept honest by the build. This page is generated from the MCP server's source code, and the site refuses to build when the two disagree, so the list can't silently drift from what the server actually serves. Last regenerated 2026-08-19.

Connection & workspaces

The handshake. A fresh session starts here: confirm the credential works and see which workspaces the connection can reach. Workspaces are separate brands, and nothing crosses between them.

Tool	What it does
`whoami`	Confirms the connection works and reports which workspaces the credential is bound to. The first call a fresh session makes.
`list_workspaces`	Lists every workspace the connection can reach and which one is the default. Tools that take a workspace pick it from this list.

Boards

A board is the canvas one campaign lives on. These tools create boards, read them back in full, and keep the canvas tidy.

Tool	What it does
`list_boards`	Lists boards across every connected workspace, each with the link a human opens to watch it.
`create_board`	Creates a blank board and returns its link, so the agent can hand you a page to follow along on.
`get_board`	Reads a whole board back in one call: phases, cards, connections, timings, statuses, and the board's card vocabulary. This is how a fresh session picks up a campaign where it left off.
`set_board_summary`	Writes the short summary shown on the board overview.
`set_board_anchor_date`	Sets the board's launch day, the date that relative timings like T-14 resolve against. Moving it never rewrites any card.
`arrange_board`	Tidies the canvas: snaps phases to the grid and re-slots each phase's cards in reading order, without restructuring a layout a human arranged by hand.

Phases

Phases are the lanes a board is organized into: Research, Audience, Create, Launch. The agent organizes by phase, and the canvas grid follows.

Tool	What it does
`create_phase`	Adds a lane to the board, with an icon and a place in the grid, appended at the end or slotted under an existing phase.
`list_phases`	Lists a board's phases in order, with their positions in the grid.
`update_phase`	Renames or restyles a phase in one reversible edit. Renaming is also how a stage gets repurposed; deleting one takes human approval.
`set_phase_schedule`	Turns an empty phase into a schedule view that renders every timed card on the board in chronological order, or turns it back into a normal lane.
`set_card_phase`	Moves a card into a phase, or out of every phase.
`link_phases`	Connects two phases with a typed arrow to describe the pipeline, precedes by default.
`unlink_phases`	Removes a connection between two phases.
`list_phase_edges`	Lists the connections between a board's phases.

Cards

Cards are the work itself: research notes, audience profiles, briefs, emails, ad creative, results. Everything the agent writes lands as a card a human can read, edit, and approve.

Tool	What it does
`create_card`	Creates a typed card: a structured deliverable such as an email when the content matches one, or a plain text card for notes, research, and strategy. Citations, timing, and status ride along in the same call.
`get_card`	Reads one card in full, body included.
`update_card`	Edits a card with a version check, so two writers can never silently overwrite each other. Every edit snapshots the previous version into history.
`set_status`	Moves a card through the board's statuses. The move to approved is gated: a card with an unfilled image slot is refused.
`set_card_timing`	Records when a card is meant to happen, as a calendar date or an offset from the launch day, or clears it. A timing is information for the schedule; nothing sends or fires because of it.
`list_card_versions`	Lists a card's version history, newest first.
`query_cards`	Pages through a board's cards without their bodies, the cheap way to scan a big board.
`crown_winner`	Crowns the winning variant of an A/B test: the winner goes live and the losing variant is archived, in one call.
`add_live_link`	Records where a card now lives on an external platform, such as the Brevo campaign or Meta ad it became, so the board can point at the real thing. A made-up link is refused when Plainpaper knows that platform's real link shapes.
`remove_live_link`	Removes one of those platform links, for when the campaign was deleted on the other side or the wrong link was recorded.

Card connections

Typed arrows between cards keep the lineage visible: which research informed which strategy, which strategy produced which email, and which email goes out before which.

Tool	What it does
`link_cards`	Connects two cards with a typed arrow, such as informs, produces, targets, measured by, variant of, or precedes for send order in a sequence.
`unlink_cards`	Removes a connection between two cards.
`list_edges`	Lists every connection on a board, the lineage graph the agent reasons over.

Templates

Templates are ready-made boards, and the playbooks in the product ship as templates: phases, starter cards, connections, and guidance for the agent, applied in one step.

Tool	What it does
`list_templates`	Lists the templates a workspace can use: the official set plus its own private ones.
`get_template`	Reads a template's full structure and the guidance the agent follows when working from it.
`create_board_from_template`	Creates a board pre-filled from a template, with its phases, starter cards, connections, and pinned guidance, and returns the board's link.

Deliverables & mockups

Deliverables are card types with real structure: an email card has a subject, a preheader, and rendered HTML rather than a blob of text. Mockups are the platform frames creative is reviewed in.

Tool	What it does
`list_deliverable_types`	Lists the structured deliverable types this Plainpaper supports.
`get_deliverable_type`	Reads one deliverable type's full authoring contract: its fields, its asset rules, and how to write it.
`list_mockups`	Lists the frames a creative can be previewed in, such as an Instagram feed post or a TikTok ad, with each surface's art direction and safe zones.

Assets & media

Images, video, and files live privately inside Plainpaper. There are several upload paths because agents hold media in different ways: as a web address, as a local file, or as raw bytes.

Tool	What it does
`upload_asset_from_url`	Attaches media to a card from a web address. Plainpaper fetches the file server-side, which makes this the preferred path for anything beyond tiny files.
`upload_asset`	Attaches a tiny file to a card from bytes sent along with the call itself. Anything larger belongs on one of the other upload paths.
`create_asset_upload`	Starts a direct upload for a file the agent holds on its own disk and returns the address to send it to.
`finalize_asset_upload`	Completes a direct upload on the fallback path, verifying the file arrived intact.
`get_asset`	Hands the agent an asset it owns, as a short-lived link or as bytes, in the shape a destination platform needs.

Actions & approvals

The control model. Anything consequential becomes a proposal that waits for a human click, and the server refuses agent self-approval for anything involving money or irreversible change. Plainpaper never performs a send itself.

Tool	What it does
`propose_action`	Proposes something for human approval: an external send such as a campaign going live, or a structural board edit such as deleting a phase. The proposal waits until a human decides.
`approve_action`	Refused by the server for money, sends, and irreversible or structural changes; those approvals are a human click. Only trivially reversible kinds can pass.
`reject_action`	Rejects a pending proposal, for when the plan changed before anyone approved it.
`get_action`	Reads a proposal's current state and the cards it came from, so the agent knows whether it may proceed.
`list_pending_actions`	Lists everything on a board still waiting for approval.
`mark_executed`	Records that an approved action has been carried out on the external platform. Plainpaper never executes anything itself; this write is how the board learns it happened.

Comments

Comments are how the human steers without writing a prompt: each one is anchored to a card or a phase, and the open ones are the agent's work queue.

Tool	What it does
`list_comments`	Lists the human's comments on a board, each anchored to a card or a phase, filterable to just the open ones.
`resolve_comment`	Marks one comment resolved once the work it asked for is done.
`resolve_all_comments`	Resolves every open comment on a board in one sweep.

Brand guidelines

The workspace's brand memory: tone of voice, brand files, palettes, and writing rules. A board can require the agent to read and apply them before it writes a word.

Tool	What it does
`get_guidelines`	Reads the workspace's brand library: tone of voice, brand files, source links, color palettes, and the writing rules the agent applies before drafting anything.
`create_guideline_block`	Adds a block to that library: text, a link, a color palette, a brand file, or a voice rule set such as Prevent AI language.
`update_guideline_block`	Edits a guideline block, leaving whatever is omitted unchanged.
`delete_guideline_block`	Removes a guideline block from the library.
`upload_guideline_asset`	Ingests a brand file such as a logo or font from a web address, fetched server-side, ready to become a file block.

Connect your agent: how these tools reach your agent in the first place.
Approvals & control: the permission model the action tools enforce.
Prompt library: you never name a tool in a prompt; this is what you say instead.

Agent tools