AI workers for Miro

What is an AI worker for Miro?

An AI worker for Miro is an AI agent scoped to one visual collaboration job, such as turning a workshop board into written action items or keeping a planning board summarized for people who were not in the session. It reads boards in the one Miro team you connect, through your own Miro sign-in, and it can create or change board content only where you bind the tools that do that.

What these workers do

Turn a workshop into action items

Reads the sticky notes and frames after a session and writes the decisions and next steps back onto the board as a document or a table.

Summarize a board for people who missed it

Reads a planning or research board on a schedule and produces the short written version, so the canvas stays legible to anyone who was not in the room.

Draw diagrams from a description

Generates flowcharts, mind maps and architecture diagrams onto a board from written input, leaving the arranging and the judgement to people.

Report what changed on a long-running board

Re-reads a board on a cadence and writes up the differences, which is how a board that lives for months stays reviewable.

Answer questions from the canvas

Makes board content readable to a worker whose job is elsewhere, so a question about a past decision can be answered from where it was actually made.

How an AI worker runs in Miro

The board is where the decision was made

Reading is most of the value and needs no write tools

What a worker writes, your colleagues see

Edits replace, and boards hold human work

One team per connection, and a daily call budget

Miro questions, answered.

Can a worker change or delete our boards?

Only with tools you deliberately bind to it. A worker built to summarize holds read tools and cannot create, edit or delete anything on a board, however it is prompted. Writes are granted one tool at a time, so a worker allowed to add a document does not thereby gain the ability to overwrite a table or delete a widget. For recurring jobs the safer shape is a worker that reads the board and creates new content beside it rather than editing what people wrote.

Which boards can a worker reach?

The boards in the one Miro team you pick during sign-in, and only the ones the connecting user can already open. Miro scopes this kind of connection to a single team at a time, so boards in another team are not reachable at all rather than merely restricted, and moving a worker to a different team means reconnecting deliberately. Board permissions still apply on top of that, so a board the connecting user cannot open stays invisible to the worker too.

Will my team see what a worker writes?

Yes, and it is worth knowing before binding a write tool. Anything a worker creates appears on a shared board under the identity that connected it, so a document, diagram or table it produces is visible to everyone with access to that board, and a reply posted into a comment thread can notify the people following it. What a worker adds is not a private draft, which is exactly why those tools are granted per worker rather than by default.

Why did a worker stop before finishing?

Usually the day's Miro call allowance ran out. Miro caps agent tool calls per day by plan and every call counts, reads included, so a worker reading a large board on a frequent schedule can exhaust a smaller plan's budget before the day is over. The worker is told plainly that the limit was reached rather than failing silently. Running less often or reading a narrower part of the board is the usual fix, and larger plans can raise the cap with Miro.

Do we need a paid Miro plan or an admin to switch this on?

Miro's agent access works on every plan, free teams included, and on most plans it is available without anyone enabling it. Enterprise is the exception worth checking first: there it may be off until a company admin turns it on, and an admin can also limit it to selected teams or maintain a list of approved clients. If a connection is refused on an Enterprise account, that admin setting is the thing to look at before anything else.

Is there a record of what a worker did?

Yes, in two places. Every call a worker makes here is logged with the worker, the tool and the time, reads and writes alike, so a document that appeared overnight is traceable to the run that created it. Miro keeps the board's own history separately, showing the change alongside everything people did, which is what you want when the question is not what the worker did but whether it was the worker at all.

What AI workers can do in Miro

The tools a worker can be granted in Miro once you connect it. A kit grants only the ones its job needs, and you can narrow them further on the worker.

Create a board

Create a new, empty Miro board in the connected team. The board is real and visible to teammates with access, and it counts against the team's board allowance.

List items on a board

Page through the items on a board, optionally filtered by item type or by the frame or container holding them. Returns item identifiers and positions rather than full text.

Search boards

Find boards in the connected team by name or keyword, and return the board list a worker can then read. The starting point when the job does not already name a board URL.

Create board items from SVG

Create many board items at once from an SVG layout, the tool behind building a whole workshop board or template in one call.

Read a board region as SVG

Read existing board items back as SVG, giving a worker the layout and positions rather than only the text. Miro's current replacement for the DSL-based layout reader.

Update board items from SVG

Edit existing board items by finding and replacing parts of their SVG representation. A broad match can rewrite more of the board than intended.

Create a code widget

Add a code snippet to a board as a syntax-highlighted widget, for sharing an example alongside the diagram it belongs to.

Delete a code widget

Remove a code widget from a board. The widget and its contents are gone, and nothing in this connection restores them.

Read a code widget

Read one code widget's source and metadata off a board, for reviewing or explaining a snippet a team has pinned there.

List code widgets

List the code widgets on a board, so a worker can find the snippet it needs before reading it.

Update a code widget

Replace the code inside an existing widget. The previous snippet is overwritten in place.

Read comments

Read the comment threads on a board or on one item, including what teammates raised and whether a thread is still open.

Reply to a comment

Post a reply into an existing comment thread. Teammates see it under the worker's connected identity and may be notified, so it is visible outward, not just a board edit.

Resolve or reopen a comment

Mark a comment thread resolved, or reopen one. Resolving hides an open question from the people tracking it.

Explore a board's structure

Map the high-level shape of a board: its frames, documents, prototypes, tables and diagrams. Use this to find the right region before pulling full content.

Read board content as text

Pull the written content of a whole board or one item as text, which is how a worker actually reads sticky notes, shapes and frames. Miro bills this one against the team's AI credits.

Create a diagram from DSL (legacy)

Build a diagram on a board from Miro's older DSL text. Miro has deprecated this in favour of the Mermaid diagram tools, which are the better choice for new work.

Create a Mermaid diagram

Render a Mermaid definition as a real diagram on a board: flowcharts, mind maps, UML and ER diagrams. Adds visible items teammates will see.

Update a Mermaid diagram

Replace the definition behind an existing Mermaid diagram, redrawing it in place. Whatever the previous version showed is overwritten.

Create a document

Place a new structured document on a board from markdown, for write-ups such as summaries, briefs or retro notes. Visible to everyone who can open the board.

Read a document

Read the full content of a document item on a board, the Miro equivalent of opening a written doc rather than skimming the canvas.

Update a document

Edit an existing document by finding text and replacing it. A wrong or overly broad match rewrites content a person wrote, and there is no undo through this connection.

Add an image to a board

Place an image item on a board, from an uploaded file or a link. The picture becomes part of the board for everyone with access.

Read image data

Fetch an image item's metadata and its bytes as base64, so a worker can look at a picture on the board rather than only its caption.

Get an image upload link

Mint a single-use upload link that image creation then draws on. It grants a place to put a file, so it is the first half of adding an image, not a read.

Get an image download link

Return a download link for an image on a board, the lighter alternative to pulling the bytes inline.

Create board items from DSL (legacy)

Create multiple board items from Miro's older DSL text. Miro is retiring this family in favour of creating items from SVG.

Read board items as DSL (legacy)

Read board items back as Miro's older DSL text. Miro is retiring this family, so prefer reading the board as SVG for new work.

Update board items from DSL (legacy)

Edit existing board items through find-and-replace on their older DSL representation. Being retired in favour of the SVG equivalent.

Create a prototype

Build an interactive Miro prototype on a board from one or more HTML screens, turning a described flow into something teammates can click through.

Read prototype screens

Read the screens and metadata of a prototype on a board, for reviewing or documenting an interactive mockup a team has built.

Create a table

Add a table to a board with typed columns, for structured output such as action items with owners, priorities and due dates.

Read table rows

Read rows out of a table on a board together with their column definitions, so tracked data such as action items or status lists can be reported on.

Add or update table rows

Upsert rows into a table by matching on a key column, adding what is new and overwriting what already matches. The overwrite reaches rows a person may have edited by hand.