MCP tool reference

Every tool the Laimonade MCP server exposes to a coding agent, what each one does, and whether it reads, writes or removes — checked against the server registry at build time.

Last reviewed · maintained by Founder

What this page is

The published contract for the Laimonade MCP server, verified against server v0.11.0. An agent is told to call what this page names, so a tool documented here that does not exist is a defect rather than a stale note — scripts/check-mcp-tools.mjs compares this table against the server's own registry and fails the build if they disagree.

You do not need to memorise any of it. The server hands your assistant the workflow when it connects, so in practice you ask for what you want in plain language. This page is for when you want to know exactly what an agent can reach.

What do the permissions mean?

Every tool declares one, and your MCP client uses it to decide when to ask you first.

PermissionMeaningTypical client behaviour
ReadReturns data, changes nothingRuns without asking
WriteCreates work or moves it forwardRuns without asking
DestructiveTakes something away from where a person put it, or unwinds a closureAsks for confirmation

Most of the list is reversible. The destructive ones are marked that way because they undo a human decision rather than because data goes away — archived items are recoverable from the Archive view. delete_milestone is the exception worth knowing about: it does remove the milestone, which is why it is refused while any epic still points at one, and why cancelling is the better move when work actually happened.

Connection

ToolWhat it doesPermission
list_projectsThe projects this connection was granted at sign-in, with their ids and names. More than one means every other call needs a project argument.Read
create_projectA new project, with this connection granted access to it immediately — so the rest of these tools work against it without reconnecting. For work that has no project yet: a repository you have just started, or one nobody tracked. The new project starts on a 14-day trial and the caller becomes its owner.Write

| link_repository | Track GitHub repositories against the project, so commits, pull requests and CI results start feeding the Kanban and the delivery signals that close items. Takes what git remote get-url origin prints, or owner/name, or an array — a project usually spans several. Safe to call twice: an already-tracked repository says so, and one GitHub has renamed since is corrected. | Write | | complete_onboarding | Record what the project is FOR — the business context, and the initial roadmap and backlog generated from it. A project that has never been through this has no goal, so nothing can be planned against it. Call it after the repositories are linked. | Write |

The setup order is create, link, then complete, and it is not arbitrary: linking first is what lets onboarding see the code it is writing a roadmap about.

complete_onboarding asks the PERSON its three questions through MCP elicitation rather than letting an agent answer them, because the answers are about the business and not about the repository. A client that does not support elicitation must therefore pass the three fields itself — the schema makes them optional precisely so that a client which does support it can be asked instead.

create_project has two limits worth knowing before you reach for it. It is a paid-plan feature, and the project the call is made FROM is the one that decides — so a trial project cannot create another. And it needs a connection signed in as a person: a project API key cannot create projects, which is deliberate, because an API key is scoped to the project it belongs to and creating a new one would widen that scope without anyone agreeing to it.

Finding work

Every get_* call returns a numbered menu, and those numbers are what load_items takes — there are no document ids to copy. Numbers always refer to the most recent menu in the session.

ToolWhat it doesPermission
get_all_readyNumbered menu of every item in Ready on the current week's sprint.Read
get_storiesReady stories and feature requests only.Read
get_bugsReady bugs only.Read
get_improvementsReady improvements only.Read
get_epic_storiesThe Ready column with unparented items removed, grouped under each parent epic and carrying its title and description. Takes no arguments: the selector is "has a parent", not "this epic", so it cannot read one epic.Read
get_milestonesRoadmap milestones with status, target date and linked epics. Call it before creating an epic, so work attaches to an existing milestone instead of a duplicate.Read
get_quarter_valueThe quarter's expected and realised business value and the difference between them, per outcome and in total.Read
get_management_metricsThe numbers behind the management report: velocity per sprint, cycle time, review wait, the share delivered unattended, carry-over, milestones with forecast dates and the quarter's value. weeks sets the trend length (default 8); quarter (YYYY-Qn or last) returns the quarterly edition instead.Read
load_itemsFull detail for menu numbers, e.g. "1,3" — description, acceptance criteria, estimate, parent epic.Read
find_backlog_itemsSearch item titles and get back matching ids. The way in when you know what something is CALLED but not where it sits — menus only cover this sprint's Ready column. Returns summaries; pass an id to get_backlog_item for the detail.Read
search_backlog_itemsFind items by what they are ABOUT, not their title words — ranked by meaning, with a similarity on each row (0.60 or more is usually the item described; nothing under 0.45 comes back). Use it before filing ("is there already an item for this?") and before linking work ("which item does this change belong to?"). available: false means the search could not run — fall back to find_backlog_items. Filter by status and type; archived items are never searched.Read
list_backlog_itemsThe backlog as a list, without knowing any title: everything matching a status, type, priority, epic, assignee or "no epic", sorted by priority (P1 first) then most recent change, in pages of up to 100 with a total. Follow nextCursor until it is empty to get the whole list. Filter by date too: createdOn / updatedOn take one day ("today", "yesterday" or YYYY-MM-DD) and createdAfter / createdBefore / updatedAfter / updatedBefore take a day or an exact time, with days in your project's timezone. For example, everything in review that was created yesterday. Rows name the epic, milestone, assignee, repos, and when each item was created and last updated; includeDetails adds descriptions and acceptance criteria.Read
get_backlog_itemOne item by id, in any non-archived status, plus its parent epic and the milestone it rolls up to. Given an epic id it also lists that epic's children — the only way to read down the hierarchy. Reaches items that are not on this sprint, which menus cannot.Read
get_backlog_itemsThe same read for a LIST of ids, in one call. Every id gets a row: live work, or a reason it is not — archived, not found, not an id — and an archived row says whether the work shipped or was dropped. Order and duplicates come back as asked. Use this whenever you hold more than one id; asking one at a time is how an agent discovers a stale list by failing.Read
get_backlog_contextWhole-sprint dump. Prefer get_all_ready and load_items, which return only what was asked for.Read

Understanding before editing

ToolWhat it doesPermission
get_project_rulesYour own rule files — CLAUDE.md, AGENTS.md, .cursor/rules/*.md — plus the built-in orchestration and regression playbooks.Read
get_regression_contextThe do-not-break invariants, path hints and search keywords for the areas about to be edited.Read

An agent that calls these two before changing existing behaviour is the difference between a fix and a regression. Both are cheap and neither costs credits.

What a read gives you back

load_items, get_backlog_item and get_backlog_items return the same item shape. Most of it is what you would expect from a tracker; three fields are worth knowing about because nothing else on this page implies they exist.

FieldWhat it holds
title, description, type, status, priorityThe item as the Kanban shows it
acceptanceCriteriaThe list an agent is asserting when it submits for review
estimatedPoints, estimatedEffortThe estimate, where one was made
attachmentsFiles attached to the item
mcpExecutionOrchestration hints: repos to touch, dependencies, parallel group
discoveredFromThe item whose implementation surfaced this one. Provenance, not hierarchy — an item keeps its epic parent as well
inferredDeliveryPresent only when a commit, rather than a person, put the item in its current status
assigneeWho holds it, or null. Never omitted — see below
externaltrue when the item was requested by someone outside the team, for example through Laimonchat
liveWhether the work is in production: production, since, provider, url. True only when every commit that delivered the item is in a finished production deployment of every directory it changed
ciThe state of the checks on the item's newest commit, with the failing ones named. Absent when there is nothing to report
previewsHosted branch previews of the work: repository, branch, status (building, ready, failed, expired) and URL
_idThe id to pass back to any tool that takes one

inferredDelivery, and why a missing field is an answer

An item's status usually moves because somebody moved it. Sometimes it moves because a commit was matched to it, and then this field carries the evidence: the short commitSha and message, the repo and author, committedAt for when the author wrote it and mappedAt for when it was matched — deliberately two dates, because they answer different questions — plus a confidence and a kind.

The useful part is the absence. No inferredDelivery does not mean nobody moved the item; it means no Git evidence did, which is how you tell a human decision from an automated match without asking anyone. A status you believe is wrong can therefore be traced to the commit that caused it and corrected, rather than argued about.

assignee is null, never absent

An omitted field cannot be told apart from an unassigned item, so "find everything with nobody on it" would be unanswerable. It is always present, and it carries a name as well as an id, because an id alone is not something you can read out.

Creating roadmap and backlog

ToolWhat it doesPermission
create_milestoneA roadmap milestone with a title and target date.Write
create_epicA backlog epic, optionally under a milestone.Write
create_storyA story, optionally under an epic.Write
create_bugA bug, optionally under an epic, with the item it was discovered from.Write
create_improvementAn improvement, on the same terms as a bug.Write
create_itemsFile a whole reviewed list of stories, bugs and improvements in one call — for when a walkthrough produced a set rather than one item. Each entry is attempted; a duplicate in the middle stops nothing and nothing is rolled back, so you get a row per entry saying what happened. Same duplicate checking as the single-item tools.Write
update_milestoneCorrect a milestone's title, description, target date or status. Milestones are not write-once.Write
backfill_epic_linksFile every open item that has no epic: items confident enough are placed under their best epic, the plausible rest are collected into ONE decision for a person to accept, and the others stay unparented with a reason. Returns the counts and the decision's id; limit caps one call. Undo a link with update_backlog_item.Write

Parentage is not write-once: an item filed without an epic can be moved under one later. Omitting a parent is better than inventing one.

Nor are epics write-once. update_backlog_item corrects an epic's title, description, acceptance criteria, priority and milestoneId — the milestone it rolls up to, which used to be settable only when the epic was created. It refuses the remaining structural fields — points, epic parent, execution metadata, review evidence — because they mean nothing on an epic: an epic has no epic parent, and its points roll up from its children. The refusal says which fields would have worked rather than only that the call failed.

milestoneId is refused on a story, bug or improvement, which inherit their milestone through their epic — and refused there even when the value is null, since passing the field at all says something about the model that is not true.

An epic attached to no milestone contributes to no roadmap progress. get_backlog_item on an epic reports its milestone as null rather than omitting the field, so that state is visible rather than merely absent.

Moving work through the Kanban

Two calls belong before any code is written, and agents skip both unless told:

  • Put the item in Ready first. An item that is not on the current sprint's Ready column — one the agent has just filed, or one it found by name — goes there with add_to_active_sprint and column ready before editing starts, so the Kanban shows what is being worked on. Hand-over refuses an item that is not Ready.
  • Link the work before the first commit on each item. link_work_to_story tells Laimonade which item the next commits belong to. load_items does this only for the first item it loads, and an item found by name is not linked at all. Focus is per session: a second agent working in the same project never changes yours.
ToolWhat it doesPermission
add_to_active_sprintPut a backlog item on this week's sprint — Ready before coding, or straight to In Review when the work is already done. Takes automatedTests / humanVerification when it lands In Review.Write
update_ready_itemEdit a Ready item on the sprint: title, description, acceptance criteria, priority, points, epic, execution metadata.Write
update_backlog_itemThe same edits for an item in any non-archived status, addressed by id. Also edits an epic's title, description, acceptance criteria, priority and milestone.Write
update_itemsMany updates in one call: up to 50 entries, each taking the same fields as update_backlog_item and checked the same way. Every entry is attempted and nothing is rolled back, so the reply lists each one as applied or refused with the reason.Write
submit_for_reviewMove Ready items to In Review. Asserts the acceptance criteria are met. Batches with items="1,2,3". Pass automatedTests (what you ran, with a result each) and humanVerification (steps plus what success looks like) — both render on the item for whoever reviews it. Can also name the commits that carry the work (commits, with repository and full sha), so review inspects them directly; only commits already pushed to a linked repository count.Write
deploy_itemStart the deploy path configured for each repository, or each directory of a monorepo, that an item changed and that does not have its commits yet (a GitHub workflow or a Fly.io deploy). targets, such as owner/repo/backend, narrows it. Owners and administrators signed in as themselves only — the shared API key is refused. Refused unless the item's commits are on the default branch, it is not already live and no deploy of that target is running. The outcome shows on the item as live.Write
link_work_to_storyDeclare which item is being worked on, before the first commit on it. Call it for each item: load_items links only the first item it loads. Per session — another agent in the project never changes yours.Write
remove_from_active_sprintTake an item off the sprint and back to the backlog without marking it done.Destructive
reopen_itemUndo a wrong "done". Requires a reason, clears the closure markers, and leaves a closed sprint's delivery record intact.Destructive
archive_backlog_itemRetire an item, recoverable from the Archive view. Guarded while it is Ready or In Review, and for an epic until its children are archived.Destructive
delete_milestoneRemove a milestone. Refused while any non-archived epic still points at it. Prefer update_milestone with status cancelled when work actually happened — it keeps the history.Destructive

There is no tool that marks an item Done. submit_for_review is as far as an agent can take work, by design — see what Laimonade will not do.

Having Laimon code an item

ToolWhat it doesPermission
start_coding_runHave Laimon code one story, bug or improvement unattended, in its own sandbox, on a laimon/<item> branch of a linked repository. It ends in a pull request a person must approve. Pass repo only when the project links several. Refused, with the reason, when the budget, the plan, a run already in progress or a missing repository says no.Write
get_coding_runHow a run is going, or how it ended — by run id, or an item's latest run: status, why it ended, what the agent last did, the pull request, tokens and cost. Runs take minutes; poll every minute or two.Read
cancel_coding_runStop a run that is starting or in progress. Its sandbox is destroyed and work not yet pushed is lost.Destructive

Every run also shows on the Coding page in the app, and nothing reaches your main branch until a person approves the pull request.

Reporting back

ToolWhat it doesPermission
report_blockerSurface an impediment where a human will see it without being asked.Write
report_deliveryRecord a delivery against an item with its commit SHA.Write
attach_filesPut files on a backlog item — the same attachments a person sees on the card. Bytes go inline as base64 (a data: URI is fine): up to 5 files per call, 1 MB each once decoded, and PNG, JPEG, WebP, GIF, PDF, plain text, JSON or Markdown. Names the item by id, by menu number, or falls back to the loaded item. A call that is refused, or that fails partway, attaches nothing. For a file already on disk, use create_upload_url instead.Write
create_upload_urlAttach a file that already exists on your machine — a screenshot, a log — without encoding it. Returns a one-time upload URL and a ready curl -T command: the URL accepts exactly one file within 10 minutes, up to 1 MB, in the same types as attach_files. Names the item the same way.Write
confirm_uploadAfter the curl upload, attach the file to the card exactly as a browser upload would. A file whose size or type differs from what was declared is rejected and nothing is attached. Safe to repeat: a second call returns the same attachment.Write
list_pending_asksThe whole queue of decisions waiting on you, not just the few that ride along on a read. Filter by severity or topic; ask for newest to see what has arrived lately.Read
answer_pending_askRecord the answer a PERSON gave to a decision Laimon is waiting on. Session-opening reads carry those decisions once per session — see decisions waiting on you.Write
record_decisionWrite a decision taken while implementing against the item it was made on — what was decided, why, and what was rejected. For a choice that shapes the work: a library, a data shape, a trade-off accepted on purpose. Not for progress notes.Write

record_decision earns its place on the alternative rejected. A diff shows what was decided and never what was considered instead, which is the half somebody asks about months later and the half that is gone by then.

Resources

Resources are raw reads with no menu numbering. Prefer the tools; these exist for clients that work better with resources.

ResourceWhat it returns
laimon://sprint/currentThe full current sprint. Prefer get_all_ready plus load_items. Subscribable — see below.
laimon://story/{storyId}One item by id, in any status — not limited to the Ready column.
laimon://rules/currentThe latest project rule files. Prefer get_project_rules.
laimon://regression/invariantsThe whole do-not-break registry. Prefer get_regression_context, which filters it.

Being told when the sprint changes

laimon://sprint/current is the one resource you can subscribe to. A client that calls resources/subscribe on it is sent notifications/resources/updated whenever the sprint changes underneath it — the weekly rollover closing and archiving the previous sprint, an item being added to the sprint, an item moving into In Review.

It exists for one specific failure: an agent holding item ids from the current sprint had no way to learn the sprint had rolled over, so it found out by asking for archived items one at a time and being refused. When you get an update, re-read the resource — or pass the ids you are holding to get_backlog_items — and drop what has gone.

Nothing else accepts a subscription, on purpose. A subscription is a promise to report changes, and accepting one for a resource with no change source would leave you waiting for an event that cannot arrive. A subscription also lives only as long as the session that made it: re-subscribe after reconnecting.

Treat an update as a hint to re-read, not as a ledger. Delivery is best-effort: the notification travels on a stream your client opens shortly after connecting, so there is a brief window where nothing can arrive, and a notification sent then is dropped rather than queued. Do not infer state from the sequence of updates, and keep re-reading on your own cadence as well.

A connection granted several projects cannot subscribe to it, for the same reason it cannot read it — a resource URI cannot name which project it means. Use the equivalent tool.

Decisions waiting on you

Laimon sometimes needs a person to decide something — a sprint carrying more than its capacity, milestones past their target with nothing tracked against them. It raises those in Slack and by email, and where neither reaches you they simply pile up.

So the first read of each MCP session also carries any decisions still waiting, up to three, oldest and most serious first. Your assistant should put them to you in its own words and record your answer with answer_pending_ask — accepted to go ahead, or corrected with a note saying what to do instead. It is asked once per session, never mid-task, and a question you ignore comes back next session rather than blocking anything.

Those three are chosen most serious first, and oldest first among equals — which means three questions you never answer will sit at the top indefinitely and hide everything newer behind them. Ask your assistant to call list_pending_asks to see the whole queue, or to sort it by newest when what you want to know is whether anything has come up lately.

Why menu numbers, rather than ids?

Because an agent copying a 24-character id across three calls gets one wrong eventually, and the failure is silent — a valid id for the wrong item. Numbers are short, always refer to the list just returned, and a stale number is rejected rather than resolved to something else.

The cost is that numbers are session state. Ask for a different list and they change with it.