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.
| Permission | Meaning | Typical client behaviour |
|---|---|---|
| Read | Returns data, changes nothing | Runs without asking |
| Write | Creates work or moves it forward | Runs without asking |
| Destructive | Takes something away from where a person put it, or unwinds a closure | Asks 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
| Tool | What it does | Permission |
|---|---|---|
list_projects | The 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_project | A 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.
| Tool | What it does | Permission |
|---|---|---|
get_all_ready | Numbered menu of every item in Ready on the current week's sprint. | Read |
get_stories | Ready stories and feature requests only. | Read |
get_bugs | Ready bugs only. | Read |
get_improvements | Ready improvements only. | Read |
get_epic_stories | The 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_milestones | Roadmap 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_value | The quarter's expected and realised business value and the difference between them, per outcome and in total. | Read |
get_management_metrics | The 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_items | Full detail for menu numbers, e.g. "1,3" — description, acceptance criteria, estimate, parent epic. | Read |
find_backlog_items | Search 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_items | Find 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_items | The 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_item | One 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_items | The 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_context | Whole-sprint dump. Prefer get_all_ready and load_items, which return only what was asked for. | Read |
Understanding before editing
| Tool | What it does | Permission |
|---|---|---|
get_project_rules | Your own rule files — CLAUDE.md, AGENTS.md, .cursor/rules/*.md — plus the built-in orchestration and regression playbooks. | Read |
get_regression_context | The 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.
| Field | What it holds |
|---|---|
title, description, type, status, priority | The item as the Kanban shows it |
acceptanceCriteria | The list an agent is asserting when it submits for review |
estimatedPoints, estimatedEffort | The estimate, where one was made |
attachments | Files attached to the item |
mcpExecution | Orchestration hints: repos to touch, dependencies, parallel group |
discoveredFrom | The item whose implementation surfaced this one. Provenance, not hierarchy — an item keeps its epic parent as well |
inferredDelivery | Present only when a commit, rather than a person, put the item in its current status |
assignee | Who holds it, or null. Never omitted — see below |
external | true when the item was requested by someone outside the team, for example through Laimonchat |
live | Whether 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 |
ci | The state of the checks on the item's newest commit, with the failing ones named. Absent when there is nothing to report |
previews | Hosted branch previews of the work: repository, branch, status (building, ready, failed, expired) and URL |
_id | The 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
| Tool | What it does | Permission |
|---|---|---|
create_milestone | A roadmap milestone with a title and target date. | Write |
create_epic | A backlog epic, optionally under a milestone. | Write |
create_story | A story, optionally under an epic. | Write |
create_bug | A bug, optionally under an epic, with the item it was discovered from. | Write |
create_improvement | An improvement, on the same terms as a bug. | Write |
create_items | File 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_milestone | Correct a milestone's title, description, target date or status. Milestones are not write-once. | Write |
backfill_epic_links | File 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_sprintand columnreadybefore 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_storytells Laimonade which item the next commits belong to.load_itemsdoes 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.
| Tool | What it does | Permission |
|---|---|---|
add_to_active_sprint | Put 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_item | Edit a Ready item on the sprint: title, description, acceptance criteria, priority, points, epic, execution metadata. | Write |
update_backlog_item | The 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_items | Many 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_review | Move 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_item | Start 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_story | Declare 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_sprint | Take an item off the sprint and back to the backlog without marking it done. | Destructive |
reopen_item | Undo a wrong "done". Requires a reason, clears the closure markers, and leaves a closed sprint's delivery record intact. | Destructive |
archive_backlog_item | Retire 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_milestone | Remove 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
| Tool | What it does | Permission |
|---|---|---|
start_coding_run | Have 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_run | How 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_run | Stop 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
| Tool | What it does | Permission |
|---|---|---|
report_blocker | Surface an impediment where a human will see it without being asked. | Write |
report_delivery | Record a delivery against an item with its commit SHA. | Write |
attach_files | Put 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_url | Attach 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_upload | After 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_asks | The 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_ask | Record 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_decision | Write 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.
| Resource | What it returns |
|---|---|
laimon://sprint/current | The 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/current | The latest project rule files. Prefer get_project_rules. |
laimon://regression/invariants | The 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.