All servers / Project management / ezmodo MCP server
ezmodo MCP server
MCP server for ezmodo - AI-first project management
Tested by ConnectATDScore 86 out of 100. Tested 2026-11-19 on package version 1.6.0. Package: @ezmodo/mcp-server · source
Score breakdown
| Runs | 18 / 20 | |
|---|---|---|
| Tool descriptions | 20 / 20 | |
| Package safety | 20 / 20 | |
| Maintenance | 20 / 20 | |
| Adoption | 8 / 20 |
What we saw
- Starts and answers the MCP handshake: yes (2.7 seconds including download)
- Tools offered: 122
- Last published: 2026-11-18
- Weekly downloads (npm): 724
- License: MIT · Direct dependencies: 4
Want this server set up for your team?
ConnectATD builds AI automation and wires up MCP servers like this one. Tell us what you are trying to do.
Talk to ConnectATDTools and how they are described
Agents choose tools from these descriptions. Under each name you can see how many of its parameters are explained.
authenticate1 of 1 parameter describedSign this EzModo MCP server in, or report who it is signed in as. You rarely need `login`: any tool called with no credential starts the browser sign-in itself and returns its `authUrl` — SHOW THAT URL TO THE USER, then retry the original call once they have approved it. Use `status` to see which account calls run as (useful when the browser signed in silently from an existing session), and `sign_out` to switch accounts. Not needed when EZMODO_API_KEY is set.
get_organization1 of 1 parameter describedGet organization info. Returns the default/primary organization, or lists all organizations the user has access to. Use mode "list" to see all workspaces, or omit/use "default" to get the primary one.
manage_project13 of 13 parameters describedCreate a new project within an organization, update an existing one, or (re)generate a project's grounded "how it works" living description.
get_project5 of 5 parameters describedGet project info by ID (context/memory), search projects by text, or list all projects. Provide projectId for context retrieval, query for search, or neither to list all. Responses include `descriptionDocumentId` — the id of the backing rich-description Document when the description has been promoted to one (E-189), otherwise omitted. By-ID responses also carry `type` and `terminology` — the words this project uses for epics and tasks, and for their statuses (E-107). Write prose in those words; a marketing project calls an epic a "Campaign". `terminology` is absent for a type with no template, which means plain English, not an error.
manage_epic33 of 33 parameters describedCreate or update an epic within a project. Epics belong to projects (required). IMPORTANT when creating: Call get_context first for each area the epic covers to discover relevant files and integration points. Include in the description which layers/services are affected and reference specific file paths. Create child tasks that each reference specific files from context queries. Tags: pass the tag IDs you want as tagIds; the response lists keyword-matched tags you did not pass as suggestedTags, which are NOT applied — add any that fit with an update. To align an epic to an organization goal, link it to a milestone that is linked to that goal (set milestoneId) — epics have no direct goal field. BREAKING DOWN A FEATURE: pass the child tasks in the `tasks` array on create and the epic and its whole breakdown are created in ONE request — do not follow a create with a separate create_tasks call. Besides the saved request, it removes the gap between the two: a failure part-way can no longer leave an epic with no tasks that you then have to reconcile.
search_epics5 of 5 parameters describedSearch and filter epics by project, status, or text. Primary filter is by project. If no scope (projectId) is provided, searches across all projects accessible to the API key. To find epics aligned to a goal, filter by the goal's milestone (milestoneId).
list_epics1 of 1 parameter describedList all epics for a specific project. For advanced filtering use search_epics. Requires projectId.
get_epic4 of 4 parameters describedRetrieve a single epic by ID or epic number with full details. Provide EITHER epicId OR both epicNumber and projectId. Optionally include lightweight task information (id, title, status, priority, assignee). Responses include `descriptionDocumentId` — the id of the backing rich-description Document when the description has been promoted to one (E-189), otherwise omitted. Responses also include `derivedGoalIds` — the organization goal(s) this epic aligns to, derived via its milestone (epics have no direct goal field). `editors` lists the people besides the owner who may change its plan (E-259).
get_epic_plan4 of 4 parameters describedRead an epic's plan (E-259): the planned tasks, notes, status, staged links and any open planner questions, with `currentRevision`, the version number you must send back to `update_epic_plan`. Several people and their AIs can work on one plan, so read it right before you change it. Pass `includeHistory` to see who changed what, in plain sentences, and `revision` to read an older version.
update_epic_plan3 of 3 parameters describedSave an epic's plan as a new version (E-259). Send the WHOLE plan, changed where you mean to change it, plus `baseRevision`: the `currentRevision` you read with `get_epic_plan` (0 when the epic has no plan). Keep each planned task's `id` so the change is matched to the right task. If someone else saved since you read it, nothing is written and you get `PLAN_CONFLICT` with the current plan and what changed — apply your change to THAT plan and save again with its revision. Never resend your old copy: that erases their work. Keep plans simple and readable by anyone: a plain title and one line on why for each task. Only the epic's owner, its creator or an organization admin can save the plan. If you are refused, do not give up: send the SAME plan to manage_plan_proposal action "propose" and the owner can accept your changes one at a time.
get_epic_activity4 of 4 parameters describedCatch me up on an epic (E-259): what changed since YOU last looked. Returns `summary`, plain sentences you can relay to your person as-is, most important first: decisions waiting on their view, open questions put to them and open objections, comments that mention or reply to them, decisions made, new plan versions (who changed what, and which AI did it for them), and tasks added, started, finished or blocked. The details are alongside. Their own changes are left out. Call it when you start or resume work on an epic other people also work on, and before changing its plan. By default this also marks the epic as caught up, so the next call shows only newer changes; pass markSeen:false to look without that. LIVE: pass waitSeconds (up to 25) to wait for something to happen instead of hearing "nothing has changed" — the call returns as soon as someone changes the plan, comments, decides, or picks up or moves a task. Call it again to keep following a shared session. `hereNow` says who else is on the epic right now, people and their AIs; calling any epic tool shows you there too.
list_epic_comments3 of 3 parameters describedRead an epic's discussion (E-259), oldest first. Each comment says who wrote it and, when an AI wrote it for them, which AI (`agentName`). Replies carry `parentId`. Read this before planning or changing a shared epic: other people's questions and objections live here. Each comment has a `kind` (comment, question, objection, alternative); the last three stay open until `resolvedAt` is set. Pass open:true for only the ones still waiting — check it before approving a plan.
add_epic_comment6 of 6 parameters describedPost to an epic's discussion (E-259), or reply to a comment with `parentId`. Posted as the person whose key you use, marked as written by you. Mentioned people, the author you reply to and everyone following the epic are notified, and posting makes that person follow it. Write plainly: one point per comment, readable by anyone. Say what the comment is with `kind`: a `question` you need answered, an `objection` to the plan, or an `alternative` approach. Those stay open until settled, show up in catch me up, and an open objection warns whoever approves the plan. To answer one, reply with parentId and resolvesParent:true (the person who raised it, or the epic's owner, may settle it; anyone may reply).
manage_plan_proposal10 of 10 parameters describedSuggest a change to an epic's plan when you cannot save it yourself, and answer suggestions on plans you own (E-259). propose: send the plan you WANT, exactly as you would to update_epic_plan. The server works out what you changed and lists it as separate changes, each with a plain sentence, so the owner can take some and leave others. Nothing changes until they do. list: what is waiting on an epic. Open ones come first, and each change that no longer fits the current plan is flagged with the reason. review (owner, editors, creator or org admin only): `accept` and `reject` name changes by their op id. A change you name in neither is left for later and the proposal stays open. A change whose task someone has since removed is reported back as stale rather than quietly reapplied. withdraw: take back a proposal you made.
manage_milestone34 of 34 parameters describedCreate, update, delete milestones, or manage epic/suite linking and changelog generation. "draft_whats_new" returns short app-store "What's new" copy drafted from the milestone's epics (within Google Play's 500 characters) WITHOUT saving it; save it with update whatsNew. Milestones can be version releases or initiatives. "release" releases the milestone to an environment: when that environment has release gates it needs a release candidate (candidateId, else the newest active one) and is REFUSED while a required gate fails — see get_release_readiness and manage_release. "freeze" / "unfreeze" set the milestone freeze (freezeType: milestone-freeze | testing-only | stabilization | full-freeze). "move_out_deferred" moves deferred tasks out (any time, not only at release). Pass taskIds, or all:true for every deferred task in scope, and target: {type:"follow_up", milestoneId?} copies each task's epic as "E-<n> follow-up: <title>" (same description, tags, owner and feature links, linked back; an open follow-up in that milestone is reused; omit milestoneId for no milestone) and moves the tasks into it; {type:"epic", epicId} moves them into an open epic; {type:"backlog"} takes them out of any milestone (they leave their epic unless it has no milestone); {type:"cancel", reason} cancels them. Moved tasks stop being deferred and take back the status they had before (else backlog); the defer reason stays.
get_milestone6 of 6 parameters describedRetrieve a single milestone by ID, or list all milestones for a project. Provide milestoneId (or milestoneSlug) for single lookup, or just projectId to list all. Optionally include progress data. Responses include `descriptionDocumentId` — the id of the backing rich-description Document when the description has been promoted to one (E-189), otherwise omitted. `startDate` is the milestone's own start, if set. `effectiveStartDate` is when it actually starts: `startDate` if set, else the earliest start of its epics or of its nested milestones; `effectiveStartSource` says which ("milestone" | "epics" | "children"). Both are omitted when nothing is dated. A single lookup also returns `freezeHistory`: the last 5 changes of the milestone's freeze, newest first, each {state, freezeType, previousState, previousType, actorType, actorName, at, onRelease}. Read it to answer who set or lifted a freeze, and when; `onRelease` means releasing the milestone lifted it.
get_release_readiness10 of 10 parameters describedAnswer "what is blocking this release?". Modes: (1) candidateId + environment → the go/no-go for that candidate in that environment: verdict (go | go_with_waivers | no_go), every gate with status and reason, the checklist, waivers, and nextAction (the single next step). Blocking rows carry howToWaive. (2) candidateId alone → the readiness matrix: the same for every environment on its deliverable's route. Instead of candidateId, name the build as deliverable + version (+ candidate label): the release's newest candidate that was not rejected, or the one with that label (deliverable omitted = the project's default; projectId defaults to .ezmodo/config.json). (3) releaseId → the release page: route environments, candidates, checklist, contents and effective gates. (4) milestoneId (+ deliverable?) → the milestone's release overview: environments, candidates with their promotions, the checklist and the gates. (5) milestoneId + view: "status" → "where is this release?": one row per deliverable with its build, stage, the environment it is in, what it is waiting on and who (waitingOn), and nextAction, plus a one-line summary. Start here when asked what is next for a release or who it is waiting on. Set listGateTypes to get the gate types and their params instead. Environment accepts an id, key or alias ("prod", "stage"). In modes 3 and 4 the per-candidate steps appear once per build (candidateId set, with that build's state); the template they are copied from comes back separately as perBuildTemplate (rows the API marks template: true). The template is never open work: nothing can finish it, so do not report it as unfinished — read each build's copies instead.
manage_release58 of 78 parameters describedWork a release through: create release candidates, promote them, tick the checklist, waive, sign off, configure gates, and report checks/deployments from any pipeline. Promote is REFUSED while a required or reject gate fails (the error lists each blocking gate and how to waive it); there is no force — fix it or waive it with a reason. Enforcement: required blocks promotion; advisory only warns; reject is like required, and a definite failure (never pending) rejects the candidate; only gate types with canReject (suite_pass_rate, external_check, deployed_to_previous, checklist_phase) accept it. A rejected candidate cannot be promoted. Actions: create_candidate (releaseId, or version + deliverable? — the release is started if new and the label defaults to the version — or milestoneId + versionLabel + deliverable?; kind?, commitSha?, notes?); update_candidate (candidateId, notes?, commitSha?, status: active|rejected|shipped, rejectionReason? — recorded with a rejection; setting active again clears the rejection; versionLabel? renames the build, which keeps its promotions and steps — refused if another build of the release has that label, or the build was rejected); promote (candidateId, environment, notes?); sign_off (candidateId, environment, note?); approve (candidateId, environment, note? — a PERSON approves this build for that environment, where EzModo is the approver (ezmodo's own Forgejo deploys, E-307): nothing ships on approval; the deploy workflow is started with the approval's id, and the release gate holds a deploy whose approval does not match its build. Approving a build cancels live approvals of the deliverable's older builds there; approving again returns the one that stands. Only ever on the user's explicit instruction: it is their sign-off, not yours. A CI key cannot approve); cancel_approval (candidateId, environment, reason? — withdraws the live approval; a deploy not yet past the gate is then held); release_to_dev (projectId?, deliverable?, epicId?, milestoneId?, commitSha? — deploy a deliverable to dev now: EzModo records it and starts the deliverable's deploy workflow for dev. If it can't start it (no deploy workflow, the host refused) the release waits and the next merge deploys it; the answer says which. For a deliverable whose devDeploys is on_release this is how dev gets deployed. Refused (409) when the deliverable's effective devDeploys is on_merge: every merge already deploys dev); list_dev_releases (projectId?, deliverable?, epicId?, milestoneId?, limit?, offset? — releases to dev, newest first, each with runStatus, runUrl and state: waiting (no workflow started yet) | started (no run matched) | running | deployed | failed | cancelled; milestoneId includes its epics' releases; hasMore pages them. Use it to answer "is my epic on dev yet?"); RELEASE RUNS (E-331) — "release 1.6.0", "try this epic on dev": preview_run (milestoneId, or epicId + projectId?; target?: first_stop (default)|staging|all; deliverables?: ["api", {deliverable: "web", version: "1.6.0"}] — omitted, the ones changed since their last release or already planned (an epic: the ones its work touched); freeze? — the dry run: per deliverable its last release, changes, suggested version, versionOnMain and bump (none|pr), the ordered plan, and checks (severity ok|info|warn|error; canStart is false while any is an error: no deploy workflow, a version that already reached production, nothing picked, a run already going). Show the user the plan and checks before start); start (same arguments — starts it: a milestone run attaches a release at each version to the milestone, starts the deploy of deliverables main already has at that version, and bumps the rest one at a time (one bump per commit); an epic run releases each deliverable to dev as main is, no version. Gates and approvals still apply at every stop: a run never promotes or approves anything. One running run per milestone (409). Only on the user's explicit instruction); run_status (runId, o…
manage_deliverable25 of 25 parameters describedDeliverables (E-280): what a project ships on its own version line — api, web, desktop. A release is a deliverable at a version (manage_release create_release / list_releases). HARD RULE: deliverables are a release axis only. Work is NEVER linked to a deliverable and a deliverable has no progress figure; work reaches a deliverable only through a release's contents. To say what a task or epic advances, link a feature instead. Every project has one default deliverable (created automatically), and everything deliverable-specific stays hidden while it is the only one (multi: false). projectId defaults to .ezmodo/config.json. A deliverable is named by key or id. Actions: list (→ {deliverables, multi}); create (name, key? — the name CI uses, ^[a-z0-9][a-z0-9._-]{0,62}$, route?, paths?); update (deliverable, name?, key?, position?, makeDefault?, route?, paths?); paths (deliverable, paths: repo-relative folders whose commits belong to it, mode?: add|remove|replace (default replace)) — used to derive a release's contents; the default deliverable with no paths is the whole repo; route (deliverable, route: environment ids or keys it is promoted through; [] = every environment); delete (deliverable — refused for the default and for any deliverable with releases). VERSIONING (E-331): create and update take versioning — {scheme: semver|date|number|custom, pattern? (date: YYYY.MM.DD, YYYY.MM.MICRO, YY.WW; custom: r{n}, {yyyy}-Q{q}.{n}), source: files|tags|ezmodo|unknown (where the version lives; unknown = CI reports it, the default), files?: [{path, format?, key?, pattern?}] (format guessed from the path: package_json, json, pubspec, cargo_toml, pyproject_toml, gradle, info_plist, csproj, version_file, go_const, or pattern with a line containing {version}; deliverables listing the same file bump together), tagPattern? ("cli-v{version}"), buildLabel: build (+build.N) | rc (-rc.N, for npm) | store (a store build number), repo?: {provider, repo, branch?}, bumpWorkflow?: {provider, repo, workflow, ref?}, bumpGroup? (a name: deliverables with the same one are bumped together, in one PR or one run of a member's bump workflow, e.g. "cli" for cli, mcp-server and the plugin)} — sent whole, it replaces the settings. versions (deliverable, check? — last shipped, suggested next versions and hotfix in its scheme, open releases holding a version, and whether check is valid and newer); version_on_main (deliverable — what each version file holds on the connected repo's base branch); next_version (deliverable, bump?: patch|minor|major, releaseId?, milestoneId? — RESERVES: the version a build should carry when EzModo assigns it, held by its release until it ships, plus the next build label); bump (items: [{deliverable, version, commit?}] or deliverable + version, release? — on a connected repo EzModo opens one PR with one commit per deliverable, or dispatches the deliverable's bump workflow; it never merges. A deliverable versioned by tags has its tag (tagPattern) pushed instead, on the base branch's head or on commit (a full SHA): no PR, no merge. Without a connected repo, edit the files yourself from versioning.files (or push the tag) and open the PR, then report_bump); report_bump (deliverable, version, number?, url?, branch?, repo?, commitSha?, state?: opened|merged, source? — records a bump you made: the PR you opened (opened until you report it again with state merged), or a commit straight on main (merged). The release page and the release run show it, and with no connected repo version_on_main answers from the last merged one).
manage_feature17 of 17 parameters describedCreate, update, or delete a Feature (a durable product capability), or link/unlink it to existing work artifacts. Features are org-level and live on a separate axis from work — they LINK to epics/tasks/milestones/etc., they do not contain them.
get_feature15 of 15 parameters describedRetrieve a single Feature, list features for a project, view the feature tree, or list a feature's links. Provide featureId (or organizationId + featureSlug) for a single lookup; for list/tree provide organizationId AND a project scope (projectId, or projectIds for several at once) — an org can span several products, so list/tree is project-scoped (it still includes org-wide capabilities, i.e. features spanning no project). List mode is PAGINATED: the response carries total/hasMore alongside features, so use offset to page rather than assuming you got everything. Responses include `descriptionDocumentId` — the id of the backing rich-description Document when the description has been promoted to one (E-189), otherwise omitted.
search_features3 of 3 parameters describedSemantic search over an organization's Features. Returns existing features ranked by meaning-similarity to a query — use this BEFORE creating a new feature to find an existing capability the work belongs to, so the compendium stays small and free of duplicates (capture-at-build, E-164). Each result is {feature, similarity}.
manage_decision27 of 27 parameters describedCreate, update, or delete a Decision (a durable ADR-style record: title, context, options, decision, consequences, status), link/unlink it to existing artifacts, mark it superseded by another decision, or promote a task's decision-type knowledge item into a durable Decision. Decisions are org-level and LINK to features/epics/tasks/milestones/etc., they do not contain them. DECISIONS TO MAKE (open choices on an epic that several people weigh in on): create with epicId + question + choices + recommendation + requestedFrom (the people whose view is wanted; they are notified). Write the question, options and recommendation in plain language a non-developer can answer. Then "add_input" records a pick (choiceId + a one-line reason; your pick counts for the person whose key you use, and replaces their earlier one). "decide" is for the epic's owner or an editor only: pass choiceId, optionally decision (the answer in plain words) and rejectedReasons {choiceId: why}. "hold_task" makes a task wait until the decision is made (it is blocked, and released on decide); "release_task" undoes that. Do not decide on someone's behalf unless they asked you to — add a pick instead. A DECISION ON A TASK (E-333): when a choice holds up the task you are on, create with taskId instead of epicId (plus question, choices, recommendation; blocking:true to hold the task until it is decided). It goes to the Inbox of requestedFrom, which defaults to the person you work for; answering it decides it. Read the outcome with list_questions or get_decision.
get_decision9 of 9 parameters describedRetrieve a single Decision, list an organization's decisions, or list the decisions linked to a given entity (e.g. all decisions on a feature). Provide decisionId for a single lookup; provide linkedType + linkedId to list decisions linked to that entity; provide epicId to list the decisions to make on an epic (open ones first, each with everyone's picks and the tasks it holds back; add status "proposed" for only the open ones); otherwise provide organizationId to list.
manage_question14 of 14 parameters describedAsk a person something on the task (or epic) it holds up, change the question, or withdraw it. Use it instead of ending a session with a list of things left for the person: each item becomes a question in their Inbox, linked to the work it blocks. KINDS: "todo" = a step only a person can do (say exactly what, and put a deep link to the exact place in link; if the API cannot do it, also file the API gap as a task and pass its id as followUpTaskId); "question" = you need a free-text reply; "approval" = it needs approving somewhere else (link to where; nobody approves from the card). For a choice between options, ask a DECISION instead: manage_decision action "create" with taskId, question, choices and recommendation. Write the title as the question itself, in plain words a non-developer can answer, and put what, why and what each option costs in body (markdown). blocking:true holds the task blocked until it is answered. The owner (who answers) defaults to the person you work for. Read the answer later with list_questions (answeredSince). "update" changes an open question (questionId plus the fields); "withdraw" takes it back when you no longer need it. WAIT: when you cannot go on without the answer, call action "wait" with questionIds (the ids of the questions, or decisions to make, you asked). It holds up to ~50 s and returns as soon as one is answered: answered (rows with the answer), waiting (ids still open), timedOut. While you keep calling it, the person's Inbox shows you as "waiting for your answer"; stop and it turns grey within 3 minutes. On timedOut, call wait again; if you can do other work meanwhile, do it and check back with list_questions instead.
list_questions8 of 8 parameters describedList questions and decisions to make asked on a task (taskId) or on an epic and its tasks (epicId), or, with only organizationId, everything asked with your key. Each row has the kind, title, status (open, answered, done, dismissed, withdrawn; a decision: proposed, accepted, rejected), blocking, the answer {text, by, at} once there is one, and the task and epic it is on. answeredSince (an ISO time) returns only what changed since then: answered, done, dismissed and reopened questions and decided decisions. Check it when you resume work you asked about. unseen:true returns only what no agent with your key has been shown yet ("answered while you were away") and marks it shown, so each answer reaches you once; get_task and get_current_project_context already lead with it. A row with reopened:true was put back to open by the person: its earlier answer no longer stands. Paged: read total and hasMore.
manage_design23 of 23 parameters describedCreate, update, or delete a Design (an AI-authored HTML/CSS artifact in the living design system: kind theme|component|page, name, html, css, status), or link/unlink it to existing artifacts. A design belongs to a project; designs every project should use (the house theme, shared components) go in the workspace's shared-library project. Designs LINK to features/epics/tasks/milestones/etc., they do not contain them. Before authoring a new design, call get_design_system first to learn the established house style. To change an existing design, send `edits` (find-and-replace) rather than the whole html/css, plus expectedUpdatedAt. Create and update return the design's summary and new updatedAt, not its markup. action:"restore" makes an older version current again (designId + historyEntryId + expectedUpdatedAt); find it with get_design includeHistory:true and check it with diffFrom first. action:"paths" sets the code paths a THEME owns (designId + paths + pathsMode), so a project can have several themes: get_design_system picks the one owning the longest prefix of the file being written.
get_design19 of 19 parameters describedRetrieve Designs in full (html, css, description). Pass designId for one, designIds for up to 10 in one call (e.g. the components you picked from get_design_system's index), or linkedType + linkedId to list the designs linked to an entity such as a feature (summaries unless includeContent is true). In a local checkout the content is WRITTEN to .ezmodo/designs/<slug>/ (index.html, styles.css, notes.md) and the response gives the paths instead: read the files you need, edit them, and push with manage_design update fromFiles:true. Elsewhere (or with inline:true) it is returned inline; then keep the updatedAt of any design you intend to change and send it as expectedUpdatedAt. History (designId): includeHistory lists versions, newest first, without markup; historyEntryId returns one past version inline and read-only (never written to the local files); diffFrom (+ diffTo, omitted = current) compares versions as line hunks for html, css and description. Prefer a diff to reading two versions.
list_designs14 of 14 parameters describedList an organization's Designs, optionally filtered by project, kind, status, theme surface, source or a search. Returns one summary row per design (id, name, kind, status, summary, size, updatedAt), not its markup: fetch the ones you need with get_design designIds. Paged: the answer carries total, hasMore and deprecatedCount; pass offset to read further.
get_design_system3 of 3 parameters describedCall this before authoring or designing any new UI, page, or component. Returns the house style as an INDEX: the chosen theme with its CSS tokens, plus one short row per component and other theme (id, name, status, summary, size, updatedAt). Drafts are included and labelled; deprecated designs are left out. It does not include component markup: pick the components relevant to what you are building and fetch them with get_design designIds. A project can have several themes, each owning code paths: pass `path`, the file you are about to write, and you get the theme that owns it (themeReason says why) with its components first, then components for any surface; other themes' components come last under otherSurfaces. Scoped to a project (its own designs plus the shared library's): projectId, defaulting to this checkout's project. Unscoped (remote, no projectId) you get every project's designs and a theme that may belong to another project.
manage_catalog22 of 22 parameters describedCreate, update, or delete a project's Catalog, link/unlink it to other artifacts, or push a new versioned snapshot of its contents. A Catalog is a generalized, code-derived catalog (kind = notifications | analytics_events | db_schema | screens | custom); its versions are immutable { columns, items } snapshots. SCREENS (E-258): each project has one kind:"screens" catalog, its UI inventory (screens and pages, keyed by source path). Do not snapshot it by hand: action:"discover_screens" (projectId) lists what the Context Manifest shows that the catalog lacks, and action:"import_screens" (projectId, screens, optional featureId) adds them and links each to the feature. action:"sync_screens" (projectId) reconciles the catalog with the manifest and re-derives the screen flow map (navigates_to edges between screens); it cannot remove a hand-added screen or a human-confirmed edge. CAPTURE-AT-BUILD (important): whenever you change the catalog's source of truth in code, call action:"snapshot" and put the source path/commit in `source`. The server is checksum-gated — re-snapshotting unchanged content creates no new version and is a cheap no-op — so it is safe to snapshot after every change. This keeps the catalog current as a side effect of building. PREFER mode:"patch" (important for cost): send ONLY what changed, as `upsertItems` (entries to add or replace, matched by key) and `removeKeys` (entries to delete). The server merges them onto the current version. Writing out a full snapshot means emitting every entry as output tokens — on a large catalog (a db_schema with 90+ tables) that is tens of minutes of generation to change one entry. Read the current entries first with get_catalog (or list_catalog_items) to see which keys exist, then patch just those. Use mode:"replace" with a full `snapshot` only for the catalog's FIRST snapshot or a genuine full re-derivation. NOTE for db_schema catalogs: if you have shell access, a live database and the ezmodo repo, `go run ./cmd/dbschema-snapshot -upload -catalog-id <id>` from api/ introspects and uploads the whole schema without passing it through the model at all — cheaper still than a patch. LINK, DON'T CONTAIN: use action:"link"/"unlink" to relate a catalog to a feature, feature_flag, epic, task, document, milestone, goal or project (e.g. link the notification catalog to its Notifications feature and the ezmodo doc that describes it). ITEM-LEVEL LINKS (E-218): pass `itemKey` on action:"link"/"unlink" to attach the link to a SINGLE catalog entry instead of the whole catalog — this is how a task/epic that builds one entry records that relationship. With an itemKey, provide EITHER targetType+targetId (internal work link) OR url[+label] (an external URL, when the entry is handled in another system). Read entries and their links back with list_catalog_items.
get_catalog5 of 5 parameters describedRetrieve a single Catalog and, by default, its CURRENT snapshot (the live { columns, items } you read to understand the catalog). Pass `version` to read a specific historical snapshot instead, `includeVersions` to also get the version history (metadata only), or `metadataOnly` to skip the snapshot blob.
list_catalogs6 of 6 parameters describedList the Catalogs in an organization (optionally filtered by project or kind), or the catalogs linked to a given entity. Returns catalog metadata (name, kind, current version) — use get_catalog to read a catalog's snapshot.
get_catalog_diff3 of 3 parameters describedDiff two versions of a Catalog — returns added/removed items (by key) and, for items present in both, the before/after of those that changed. Use it to see how the catalog evolved between two snapshots.
list_catalog_items1 of 1 parameter describedList a Catalog's ENTRIES that carry item-level links (E-218) — each returned with its work links and external URLs attached. Only entries with at least one link are returned (unlinked entries already live in the snapshot from get_catalog); links are compact {entityType,entityId} edges and urls are {url,label}, not expanded entities. Use it to see which catalog entries are wired to work or to other systems.
list_unmapped_paths2 of 2 parameters describedList a project's unmapped code paths — former component paths that no feature owns (E-258). Each row carries the source path and the component it came from. A pending row means work touching those files links to no capability, so this is the backlog to work through when a project's features are missing code ownership.
resolve_unmapped4 of 4 parameters describedResolve unmapped code paths (E-258). "reconcile" is the one to reach for first: it closes every pending row a feature has SINCE been given a path for, so the usual flow is to set ownership with manage_feature action:"paths" and then reconcile, rather than answering rows one by one. A path several features own stays pending — shared ownership is a judgement, and those only ever produce link suggestions anyway. "assign" gives ONE row to a feature (adding that feature path, with the usual scope check), and "dismiss" records that the path belongs to no capability — the right answer for shared plumbing.
manage_feature_flag21 of 21 parameters describedCreate, update, or delete a Feature Flag (a PM-aware runtime gate: key, name, kind boolean|multivariate|config, rollout %, prerequisite parent, governance properties), advance its lifecycle status (action "transition"), or link/unlink it to the feature(s) it gates. Flags are org-level and LINK to features/epics/tasks/etc., they do not contain them. Status changes go through action "transition" (recorded in history), NOT update.
get_feature_flag4 of 4 parameters describedRetrieve a single Feature Flag (with its variants + rules) by ID, or by organizationId + key (key is unique per org). Provide flagId, OR organizationId + key.
list_feature_flags8 of 8 parameters describedList an organization's Feature Flags, optionally filtered by project, status, or kind — or list the flags linked to a given entity (e.g. all flags on a feature) via linkedType + linkedId.
evaluate_feature_flag5 of 5 parameters describedEvaluate a Feature Flag for a subject and return the served Result ({ on, variantKey, value, reason }) — for debugging a flag's behavior from chat. Resolves the prerequisite chain and runs the deterministic evaluator (status → targeting rules → percentage rollout). Look up by organizationId + key.
manage_environment11 of 11 parameters describedManage the ENVIRONMENT registry: the named environments (e.g. development/staging/production) that feature flags, test runs, deployments and release gates all key by. Environments are per-scope: org-wide (omit projectId) or project-scoped (set projectId); a project with no set of its own uses the org-wide one. Exactly one per scope is the default. Each environment can carry aliases — other names pipelines report it under ("stage", "prod"). Use action "resolve" to find which environment a reported name means. To set a flag's value IN an environment, use manage_feature_flag action "set_environment_config".
manage_task70 of 70 parameters describedCreate, update, or complete tasks. Also manages commit linking and (re)generating the task's grounded "how it works" living description. IMPORTANT when creating: (1) Call get_context first with a keyword query matching the work topic to discover relevant files, patterns, and dependencies. (2) Write descriptions that explain WHY (problem/goal), WHERE (specific files/endpoints from context), and HOW (approach using existing patterns). (3) Write steps that reference specific file paths, not vague instructions. (4) Link the feature the work advances with links:[{targetType:"feature", targetId}] (find it with search_features), and pass changedFiles — the files resolve to the features that own those paths. "link_commit" also applies the commit to the project's context manifest (added, modified, deleted and renamed files) and returns `manifest.needsSummary`: write a summary for each of those paths with update_manifest_entries. Pass updateManifest:false to skip the manifest.
create_tasks3 of 3 parameters describedCreate MANY tasks in ONE call. Use this instead of repeated manage_task action:"create" whenever you are creating more than two tasks at once — breaking an epic into tasks is the case it exists for. One call does the authentication, plan check, rate-limit accounting and database connection setup once instead of per task; a burst of individual creates is what made the app unresponsive for 45 minutes on 2026-07-28. Put shared values (projectId, epicId) at the TOP LEVEL and let the items inherit them — only override per item where a task genuinely differs. Each item accepts the same fields as manage_task action:"create". Returns a per-item result array: on partial failure retry ONLY the items marked failed, since the successful ones already exist and re-sending the whole batch would duplicate them. Limited to 40 tasks per call — split anything larger. For a single task, keep using manage_task action:"create", which also resolves code context and applies links.
search_tasks9 of 9 parameters describedSearch for tasks with filters or semantic search. Use for filtered queries (by status, priority, epic, etc). To get ALL tasks in an epic, prefer get_epic with includeTasks=true. Use search_tasks with epicId only when you need additional filtering (e.g., only in_progress tasks within an epic). When searchText is provided, uses AI-powered semantic search to find tasks by meaning. Falls back to basic text matching if unavailable.
report_untracked_work10 of 10 parameters describedRetroactively capture work you did WITHOUT a tracked task. Call this when you realize mid-conversation that you made code changes without an active ezmodo task — e.g. a "just fix this real quick" request, a quick bug fix, or work discovered while doing something else. Creates a task classified by `origin` (default "untracked"), records the branch + changed files as evidence, links the discovery chain when applicable, and starts it in_progress so it becomes your active task (also updating the desktop app). Returns the created task so you can keep tracking against it. Prefer this over silently continuing untracked.
get_task3 of 3 parameters describedRetrieve a single task by ID or task number with full details. Use when you have a specific task ID or number. To get all tasks in an epic, use get_epic with includeTasks=true instead. Provide EITHER taskId OR both taskNumber and projectId. Responses include `descriptionDocumentId` — the id of the backing rich-description Document when the description has been promoted to one (E-189), otherwise omitted. A task sent back from review has a top-level `reviewFeedback` {content, addedBy, addedAt}, the newest reviewer feedback: address it before anything else. When a person answered questions you (or an earlier session) asked on the task, it leads with `answeredWhileAway`: answered, done, not needed and reopened questions and decided decisions not shown to an agent yet (each is shown once). Act on those answers before continuing.
list_review_queue3 of 3 parameters describedList a project's tasks waiting for review (status in_review), oldest submission first. Each row has the task number, title, assignee, submittedAt, verification counts from linked test cases (total, pass, fail, blocked, skip, notRun) and a one-line summary. Read-only: agents cannot approve or send back; a human decides in the web app. approvePolicy says who may approve in this project. Paged: read total and hasMore. A task sent back returns to in_progress with reviewFeedback on get_task; address that first.
manage_recurring_task11 of 11 parameters describedCreate, update, pause, resume, delete, list, or get a recurring task schedule (E-211). A schedule creates a task on a cadence (e.g. "every weekday at 9am for three weeks"). The payload is either an inlineTask definition OR a templateId (a work template). Returns the schedule including its computed nextRunAt so you can confirm when it will next fire.
manage_work_template18 of 18 parameters describedCreate, update, delete, list, get, or instantiate a work template (E-211) — a reusable blueprint for a task or an epic. "instantiate" creates a real task (kind=task) or an epic plus its child tasks (kind=epic) into a project, applying optional overrides. Templates can also be referenced by a recurring schedule (manage_recurring_task templateId).
manage_document37 of 37 parameters describedCreate or update documents. Provide markdown `content` — it is converted to the unified document body (E-192) automatically. To CHANGE an existing document, prefer `edits` (find-and-replace on the markdown get_document returns) or, in a checkout, edit the .ezmodo/docs file and send fromFile:true, plus expectedUpdatedAt: only the parts you change are rewritten, comments on the rest stay attached, and a save someone made since you read the document is not overwritten (409). Sending `content` on update replaces the whole body. To embed a diagram document, put its id in a ```diagram-ref fence (one id, nothing else); get_document returns embeds in that form, so they survive a get → edit → update. (The legacy section model is gone — `sections` and the section ops were removed; sending them is an error.) action:"create_version" (documentId, optional note) saves the document as it is now as a named version, kept in its history as a checkpoint and never merged into later edits; use it before a risky change or to mark a milestone. action:"restore" with documentId + historyEntryId makes an older version current again; find the entry with get_document includeHistory:true and check it with diffFrom first. Editing a PUBLISHED document makes it a draft and readers keep seeing the published copy: when your change is ready, action:"submit_for_review" (documentId, optional note for the reviewer) asks a person to approve and publish it; action:"withdraw_review" takes that back. Agents cannot publish. action:"add_image" uploads an image (PNG, JPEG, GIF or WebP, up to 10 MB; no SVG) and places it below the block holding an anchor: documentId, alt, one of filePath or base64+mimeType, and one of afterHeading, afterText or append:true. For a help page or how-to: one screenshot per step where the reader must find something on screen, cropped to that element and what surrounds it, placed right after the step; none for typed-only steps or decoration. Look at each image before uploading, since a published page is public: never one showing real customer data (names, emails, real workspace titles, anything from production), secrets (keys, tokens, passwords, signed URLs, even partly masked) or the person's own private things (other tabs, notifications, their email). Use a test workspace, crop it out or skip the image; do not blur. Alt text says what the image shows and why it matters for the step, in a sentence. action:"import" brings Markdown in: projectId, optional folderId (default the project root), and one .md/.markdown file or a .zip of them, as filePath or base64+name. Each .md becomes a DRAFT document titled by its first "# Heading" (else its file name); folders in the zip become folders; a README.md or index.md becomes its folder's index page when the folder has none. Existing documents are never changed: a clashing title gets " (imported)". Relative links between imported files become document links, and local images (PNG, JPEG, GIF, WebP, SVG; up to 10 MB each) become document images. Anything not carried over (external or broken links, other files) is listed in notCarried. Call with dryRun:true first to see the plan without writing anything. action:"export" downloads documents as files: documentId (one document: format "md" gives a .md, or a .zip with an images/ folder when it has images; "pdf" gives a PDF), folderId (a folder: "md" gives a .zip of .md files with folders kept and links between them made relative, "pdf" one PDF with a contents page), or projectId alone (every document in the project). Only documents you can read are included, up to 500. In a checkout the file is written to .ezmodo/exports/ and its path returned; over the remote connector it comes back as base64, up to 5 MB.
list_org_documents3 of 3 parameters describedList an organization's ORG-SCOPED (project-less) documents (E-195). These are documents created with organizationId and no projectId — e.g. cross-project ADRs and "how it works" overviews living in the org's reserved document areas (Goals, Features, ADRs, How it works; see get_org_areas). Optionally filter to a single area/folder via folderId.
manage_document_template7 of 7 parameters describedCreate or delete custom document templates. Templates provide pre-built document structures for common use cases.
get_document16 of 16 parameters describedRetrieve a single document, or list all docs for a project. Provide documentId (or projectId + slug) for single lookup. Provide just projectId to list all docs. Single-doc content is saved to .ezmodo/docs/ and returns a file path; edit that file and push it with manage_document update fromFile:true. A re-download never overwrites edits you have not pushed (overwriteLocal:true discards them). History (single lookup): includeHistory lists versions, newest first, without their bodies; historyEntryId reads one version; diffFrom (+ diffTo, omitted = current) compares two versions as line hunks rather than two full bodies. Prefer a diff to reading two versions. A single lookup returns `access`: restricted (not everyone in the organization can read it), restrictedBy (document, folder or project), public, and yourRole (viewer or editor). When it is restricted, `accessNotice` says so: don't copy its content where other people can read it. Who can read a document is managed with get_access / manage_access entityType:"document".
get_document_template3 of 3 parameters describedRetrieve a single template by ID, or list all templates. Provide templateId for single lookup, or omit to list all.
manage_folder9 of 9 parameters describedCreate, update, or delete document folders. Folders are usually project-scoped (pass projectId), but a folder can also be ORG-SCOPED (project-less) by passing organizationId with NO projectId — exactly one of the two. Org-scoped folders are the org's document "areas"; the reserved areas (Goals, Features, ADRs, How it works) are managed via get_org_areas. (E-195)
list_folders3 of 3 parameters describedList document folders. Provide projectId for a project's folders, OR organizationId (with no projectId) for the org's ORG-SCOPED (project-less) folders / document areas (E-195). Use mode "tree" for hierarchical parent-child view, or "flat" (default) for a flat list with document counts.
get_org_areas1 of 1 parameter describedList the org's reserved document areas (Goals, Features, ADRs, How it works), creating any missing ones. Areas are org-scoped (project-less) system folders that organize cross-project documents — e.g. org-scoped "adr" and "how-it-works" documents are auto-filed into the ADRs / How it works areas. (E-195)
list_attachments3 of 3 parameters describedList file attachments. Two modes: (1) pass entityType + entityId to list the files on ONE entity (task/epic/goal/project), or (2) pass projectId to get the PROJECT-WIDE aggregate — every file across the project's tasks, epics, goals, and the project itself, each enriched with its source entity (entityTitle / entityNumber). Returns attachment metadata (id, name, mimeType, size, storagePath, uploadedAt, entityType, entityId).
get_attachment_url2 of 2 parameters describedGet a short-lived signed URL for an attachment so its contents can be fetched. By default the URL force-downloads the file; pass disposition:"inline" for a preview URL that renders in the browser — honored only for safe types (raster images + PDF), otherwise it still downloads. Get the attachmentId from list_attachments.
delete_attachment1 of 1 parameter describedDelete an attachment by ID. Soft-deletes the metadata, removes the stored file, and releases the org's tracked storage usage. Get the attachmentId from list_attachments.
manage_goal15 of 15 parameters describedCreate, update, or delete organization-wide strategic goals, or (re)generate a goal's grounded "how it works" living description.
manage_team10 of 10 parameters describedCreate a team within an organization.
get_goal7 of 7 parameters describedRetrieve a single goal or list all goals. Modes: (1) Provide goalId for single lookup. (2) Provide organizationId + goalNumber for number lookup. (3) Provide organizationId to list all goals with optional filters.
manage_link7 of 7 parameters describedAdd, remove, or verify a link between two entities. Covers blocking dependencies (blocked_by) and soft cross-entity links (relates_to) uniformly. blocked_by is only valid for task→task and epic→epic; relates_to works between any of: task, epic, project, document, feature, decision, design, test_suite, feature_flag, catalog, catalog_item (e.g. link a feature to the feature_flag that gates it). Idempotent — re-adding an existing link is a no-op, removing an absent link is a no-op. Use action "verify" to stamp a link's freshness (E-166/E-154): record that you confirmed it still correct, optionally against a commitSha — call it after touching code a linked document describes so the freshness signal stays accurate.
list_links7 of 7 parameters describedList an entity's links. Returns one row per link (source, target, linkType, createdAt, and freshness fields lastVerifiedAt / lastVerifiedBy / lastVerifiedCommitSha). By default only OUTGOING links (the entity as source) are returned — set direction:"incoming" for links pointing AT it (e.g. the features that reference this task), or "both" for the full neighbourhood, since relates_to is not always stored bidirectionally. Optionally filter by linkType (e.g. only blockers) or targetType (e.g. only related documents). Set hydrate:true to also get each target's title/status, so you can read the graph without a get_* per link.
resolve_links2 of 2 parameters describedGiven files you have touched (or are about to), return the entities you should link to: the features (product capabilities) whose owned code paths cover them, plus how confident each match is. Read-only; nothing is written. `features.owned` are capabilities that solely own a path: link them. `features.shared` are paths several features claim: pick the one your work actually advanced. `unmatchedPaths` are owned by no feature — a gap in the feature map, fixed with manage_feature action:"paths". Call it BEFORE creating work to fill in the `links` param, or after a change set to check you have not missed anything. If it returns a feature you did not expect, that is a signal your change is broader than you thought — worth reading before you continue. Paths are repo-relative (e.g. "mobile/lib/features/auth/screens/login_screen.dart").
preview_links6 of 6 parameters describedShow what ezmodo WOULD link an entity to, without writing anything. Each proposal reports `autoApplies`: true means ezmodo records it on its own, false means it wants a human or you to confirm. Use it when you want to see and choose rather than let linking happen — confirm the ones you agree with via manage_link, which records them as deliberately asserted rather than derived.
get_access3 of 3 parameters describedRead who can access an entity. Returns `resolvedAccess` — the effective entries after inheritance, with the source of each — plus `rawAccess`, the entity's own unresolved settings, which is included only when you hold admin on the entity. Requires at least viewer access to the entity itself. Supported entity types: goal, project, epic, task, document, folder. To ask whether a specific role is held, use manage_access action:"check". For a document (entityType "document"): the web's "Everyone in the organization" is inheritFromParent true (it follows its folder, else its project), "Only people I choose" is inheritFromParent false with an access list, and the roles people see are "Can view" (viewer) and "Can edit" (member).
manage_access12 of 12 parameters describedChange or test an entity's access control. Actions: "update_settings" replaces the access configuration wholesale (inheritFromParent / accessList / publicAccess); "add_entry" grants one user or team a role; "remove_entry" revokes a single entry by its id; "check" reports whether you currently hold a given role (a denial is a normal result, not an error). The three mutating actions require admin on the entity AND an API key with the `write:access` scope — a key that can edit an entity cannot change who may see it unless it was issued that scope explicitly. Note that some entities cannot carry their own access: projects do not support publicAccess, and nested folders inherit from their root folder. Documents: share with viewer ("Can view") or member ("Can edit"); a document's owner and org admins always keep access. A document inside a folder can have its own list, but only narrower than the folder: each person must already hold that role on the folder, teams are refused (share the folder instead), and it cannot be made public on its own. Restricting is not the same as internet publishing (publicAccess, usually set on a folder): send publicAccess unchanged so a restriction does not switch it on or off.
get_graph6 of 6 parameters describedWalk the compendium navigation graph outward from a root node and return the hydrated neighborhood as nodes + edges. Nodes carry lightweight display fields (type, id, title, status, projectId, kind, number, depth); edges are the entity_links relations (relates_to / blocked_by) between them, direction preserved. Use it to answer "what connects to this?" in one call. Traversal is a breadth-first walk bounded by depth and a node cap (truncated:true in the response means the cap was hit). A root (rootType + rootId) is REQUIRED — the graph is always explored from a node, not listed wholesale.
manage_tag16 of 16 parameters describedCreate, update, delete, merge, or bulk-apply tags. Tags are organization-scoped categorization labels for tasks, epics, and other entities.
list_tags19 of 19 parameters describedList, get, find entities by tags, or get AI tag suggestions. Modes: (1) Provide tagId for single tag lookup. (2) Provide organizationId to list tags with optional filters. (3) Set findEntities=true with tagIds array to search entities by tags. (4) Set suggest=true with queryText for AI-powered tag suggestions.
manage_watch2 of 2 parameters describedWatch or unwatch a task. Watching subscribes YOU (the API key owner) to notifications about the task: status changes and new comments. Use this for "watch this task for me" or "stop notifying me about this". Both actions are idempotent. Note you are subscribed automatically to tasks you are assigned, own, or comment on — this tool is for following work that is not yours.
list_watched3 of 3 parameters describedList the tasks you are watching, with their current status, priority, project and when each last changed. Answers "what is happening on the work I follow?" in one call — do NOT follow this with get_task per row. Each result also carries `reason`, why you are subscribed (manual, assignee, owner or commenter). Results are ordered most-recently-changed first, and PAGED: read `total` and `hasMore` rather than the row count — a short page and the end of the list look identical otherwise, which is how you conclude a subscription is gone.
list_notifications2 of 2 parameters describedList your in-app notifications — mentions, replies, assignments, status changes on watched tasks. Defaults to UNREAD only, which is usually what "what have I missed?" means. Pass unreadOnly: false to include already-read history.
list_issues8 of 8 parameters describedList a project's public issues, or (queue: true) its intake queue. A public issue is a SEPARATE, PUBLIC record of a bug, feature request or question, worded for people outside the organization. It is not the internal task: when it links to one, the two keep their own wording. Never paste internal details into a public issue — task titles or descriptions, code paths, customer or colleague names, internal URLs, stack traces with hostnames, secrets. Anonymous reporters are never named or quoted by identity, and their contact details are not available to you. The intake queue holds untriaged reports that arrived from outside the organization (public form, widget, API, GitHub): each needs a decision — manage_issue publish_intake (becomes a public issue, in your own public wording), convert_intake (tracked on an internal task only) or reject_intake. Queue items carry piiFindings: personal data or secrets in the report, which must stay out of the published wording. Private security reports are never in the queue and cannot be published. Results are PAGED: read `total` and `hasMore`, not the row count.
get_issue2 of 2 parameters describedGet one public issue by its number in the project (e.g. 12 for issue #12): title, body, type, labels (the names of its public tags) and tags (org tags with id, colour, and public false for one since taken out of the project's public set), state, publicStatus, statusSource, closeReason, linked taskId, vote and comment counts. Issue numbers are their own sequence, separate from task numbers.
manage_issue14 of 14 parameters describedTriage and maintain a project's public issues. A public issue is a SEPARATE, PUBLIC record of a bug, feature request or question, worded for people outside the organization. It is not the internal task: when it links to one, the two keep their own wording. Never paste internal details into a public issue — task titles or descriptions, code paths, customer or colleague names, internal URLs, stack traces with hostnames, secrets. Anonymous reporters are never named or quoted by identity, and their contact details are not available to you. Public status (open, planned, in_progress, done, closed) FOLLOWS THE LINKED TASK automatically while statusSource is "auto" (backlog/todo → planned, in_progress/in_review/blocked → in_progress, completed → done). So link the task (manage_issue action:"link_task") rather than setting publicStatus by hand; setting it by hand switches the issue to statusSource "manual" and stops the sync until action:"resume_auto_status". Actions: publish_intake (feedbackId, title, body, type, labels?, taskId?) — publish an intake report as a public issue, REWRITTEN in public wording (do not copy the report verbatim if it holds personal data); reject_intake (feedbackId, reason) — the reason may be emailed to the reporter, so write it for them; convert_intake (feedbackId, taskId) — track the report on an internal task without publishing it; create (title, body?, type?, labels?, taskId?, state?) — a maintainer-authored issue, draft by default; update (number, title/body/type/labels/publicStatus/closeReason/taskId); publish / hide (number) — make it public, or take it down; merge (number, intoNumber) — close as a duplicate of intoNumber; resume_auto_status (number) — go back to following the linked task; link_task (number, taskId) — link the internal task whose progress the issue should show (taskId "" unlinks). Requires member access to the project.
list_changelog1 of 1 parameter describedList a project's changelog: its entries (draft and published, WITHOUT bodies; read one with get_changelog_entry), the milestones that can have release notes (candidates, with hasEntry and reachedProductionAt, which is null until the milestone reached production), and verifiedSubscribers, how many people publishing an entry would email. A changelog entry is a milestone's PUBLIC release notes, worded for people outside the organization (each milestone has at most one entry). Write it for users: never paste internal details such as task titles, code paths, colleague or customer names, internal URLs or secrets. An entry stays a draft (not public) until published, and can only be published once its milestone has reached production. Requires view access to the project.
get_changelog_entry2 of 2 parameters describedGet one changelog entry by id, with its markdown body: title, version, slug (the public page address: the version, or the id when it has none), state (draft or published), milestoneId, releasedAt and publishedAt.
manage_changelog7 of 7 parameters describedWrite and publish a project's release notes. A changelog entry is a milestone's PUBLIC release notes, worded for people outside the organization (each milestone has at most one entry). Write it for users: never paste internal details such as task titles, code paths, colleague or customer names, internal URLs or secrets. An entry stays a draft (not public) until published, and can only be published once its milestone has reached production. Actions: draft (milestoneId) — the milestone's entry, created as a draft when it has none, titled and versioned after the milestone and seeded from its "What's new" (or a draft of it); returns the existing entry unchanged if there is one. There is no other way to create an entry; update (entryId, title?, version?, body?) — edit the public wording; only the fields you send change, and a published entry changes on the public page at once. version is the entry's URL slug, so it cannot contain / ? or #; publish (entryId) — make it public AND EMAIL THE PROJECT'S VERIFIED SUBSCRIBERS. Fails with not_released until the milestone reached production. Returns the entry and verifiedSubscribers; each subscriber gets an entry once, in the background, so publishing again emails nobody twice, and nothing is sent while the project's public changelog is off. Confirm with the user before publishing, and tell them how many subscribers were notified; unpublish (entryId) — take it off the public changelog (back to draft); emails already sent stay sent. Entries cannot be deleted: unpublish one instead. Requires member access to the project.
manage_roadmap11 of 11 parameters describedChange a project's public roadmap. The roadmap is a project's PUBLIC board of cards in four columns: now, next, later and shipped. Cards are shown to people outside the organization when the project's roadmap is switched on (see get_public_tracker view:"settings"), so word titles and summaries for users: no task titles, code paths, colleague or customer names, internal URLs or secrets. A card may point at one feature, epic or milestone (entityType + entityId) and may have public issues linked to it; their votes add up on the card. Read the cards first with get_public_tracker view:"roadmap". Actions: create (title, summary?, column?, entityType?, entityId?, showTargetDate?) — a new card, in column now unless you say otherwise; column cannot be shipped (use ship); update (itemId, title?, summary?, column?, entityType?, entityId?, showTargetDate?) — only the fields you send change; "" for entityType/entityId clears the reference; column cannot become shipped (use ship); delete (itemId) — removes the card; its issues are untouched; reorder (column, ids) — the full top-to-bottom order of one column's card ids; ship (itemId) — moves the card to shipped AND MARKS EVERY LINKED ISSUE NOT YET DONE OR CLOSED AS DONE, WHICH EMAILS THEIR REPORTERS AND FOLLOWERS. Confirm with the user before shipping; link_issue / unlink_issue (itemId, number) — attach or detach a public issue by its number. Requires member access to the project.
get_public_tracker9 of 9 parameters describedRead the maintainer side of a project's public issue tracker. Pick one view: settings — how open the project is: level (off: nothing public; intake: no public list, outsiders may submit when submissions are on; issues: published issues are public; open: issues plus tasks, epics and milestones through public views) and the submissions, contributors, indexing, roadmap, changelog and security toggles. Viewer; roadmap — every roadmap card (now, next, later, shipped) with its linked issues and summed votes. Viewer; comments — without number, the moderation queue of outsiders' comments by state (pending by default; visible, hidden); with number, every comment on that public issue in any state, and whether it is locked. Viewer; participants — the signed-in outsiders who take part, with their trust (participant: comments wait for moderation; trusted: visible at once; blocked: may not comment, vote or submit). Viewer; security_reports — private vulnerability reports. They never become public issues; never repeat their details anywhere public. The reporter's name and email are not included. Project admins only; github_syncs — the project's two-way GitHub issue sync, if any. Admins only; github_sync_health (syncId) — last event and error, pending and failed outbound pushes, open conflicts and recent events. Admins only; github_import_status — past GitHub issue imports, newest first. Members. Paged views take limit and offset and return total and hasMore.
manage_public_tracker22 of 22 parameters describedModerate and configure a project's public issue tracker. Everything here is visible to, or acts on, people OUTSIDE the organization, so confirm with the user before changing what the public sees. Actions: update_settings (level?, submissionsEnabled?, contributorsEnabled?, indexingEnabled?, roadmapEnabled?, changelogEnabled?, securityEnabled?, securityPolicy?, securityContact?) — only the fields you send change. RAISING THE LEVEL, OR SWITCHING ON THE ROADMAP OR CHANGELOG AT LEVEL issues OR open, MAKES THEM PUBLIC AT ONCE. Project admins only; reply (number, body) — a maintainer comment on a public issue, visible publicly at once (and mirrored to GitHub when the project syncs). Members; approve_comment / hide_comment (commentId) — publish or hide an outsider's comment from the queue. Members; block_author (commentId) — block that comment's author on this project (no more comments, votes or submissions) and hide every comment they still have waiting; returns how many were hidden. Members; lock_issue / unlock_issue (number) — stop or allow new outsider comments on an issue. Members; set_trust (userId, trust) — participant, trusted or blocked, including unblocking. Project admins only; set_security_report_status (feedbackId, status, reason?, taskId?) — triaging; converted (taskId: a task in this project that tracks the fix); or rejected (reason required, AND EMAILED TO THE REPORTER, so word it for them). Project admins only; resolve_sync_conflict (syncId, conflictId) — mark a GitHub sync conflict as looked at; it changes neither side, so fix the issue first. Project admins only.
get_ai_insights9 of 9 parameters describedGet AI-powered project analysis. Types: "project_insights" for health analysis (blockers, velocity, workload), "suggest_next" for personalized task recommendations, "dependency_graph" for critical path and bottleneck analysis, "build_failure" for why CI is red (failing checks with their output, plus which checks are consistently broken vs merely flaky), "deployment_risk" for how risky a deploy is (CI state on the commit + the environment's recent history, returned with the signals behind the score). build_failure and deployment_risk are DETERMINISTIC — computed from captured CI/CD data, no model call and no AI quota. They return evidence for you to reason over, not a verdict.
estimate_task1 of 1 parameter describedGet a Bayesian AI estimate for how long a task will take, based on similar completed tasks. Returns median and P80 (80% confidence) hour estimates, confidence level, and the similar tasks used as reference. Automatically adjusts for the assignee's historical accuracy if calibration data exists.
infer_dependencies1 of 1 parameter describedInfer task-to-task dependencies from file-level import graphs. Uses the project's context manifest (file dependencies) and task-to-file links (linkedFiles) to deterministically suggest which tasks depend on which. No AI required. Returns suggestions only — does not auto-create dependencies. Requires tasks to have linkedFiles populated (via addLinkedFile or git commit linking).
detect_git_repository1 of 1 parameter describedDetect if current directory is a git repository and match it against accessible ezmodo projects by git URL. Returns matching projects with confidence scores, and for each match the git repositories linked to that project — including the `repoId` that manage_pull_request requires. Use this to auto-suggest which ezmodo project corresponds to a git repo, and to get from a checkout to a repoId in one call.
get_current_project_context1 of 1 parameter describedDetect and read existing .ezmodo/config.json from current directory or parent directories. Returns project context if found, or null if not configured. Use this BEFORE other MCP tools to auto-detect which project you're working on. Project-First: Returns projectId and tags that can be used directly with task/epic creation tools. Caches tags locally with 1-day TTL for fast access. Also returns `projectType` and `terminology` — the words this project uses for epics and tasks and for their statuses (E-107). Write anything a person reads in those words: a marketing project calls an epic a "Campaign". Keep the API field names (epicId, taskId) as they are. A null `terminology` means plain English, not an error.
initialize_project_context6 of 6 parameters describedCreate .ezmodo/config.json for project context. Helps AI agents understand which ezmodo project they're working on. Supports single projects and monorepos. Usage: (1) Single project: provide projectId + organizationId. (2) Monorepo: provide organizationId + monorepoProjects array (no projectId needed). (3) Interactive: omit projectId to get available projects list.
manage_worktree17 of 17 parameters describedCreate, sync, or clean up git worktrees for tasks and epics. Worktrees enable parallel development by creating isolated workspaces.
list_project_worktrees2 of 2 parameters describedList all worktrees for a project with their associated tasks and status.
list_repositories1 of 1 parameter describedList the git repositories linked to a project — GitHub and Forgejo/Gitea alike — each with the `repoId` that every manage_pull_request action requires. Call this first when you need a repoId — it is the only way to get one. The id is "installationId:owner/repo" for GitHub and "connectionId:owner/repo" for Forgejo/Gitea, and neither prefix is derivable from anywhere else. Each row also has `provider` ("github" or "forgejo"; Gitea servers are connected as forgejo), `instance` (the host it lives on, e.g. "github.com" or "git.example.com"), `connectionMode` and `apiAccess`. A Forgejo/Gitea repository in `connectionMode: "webhook_only"` has `apiAccess: false`: ezmodo only receives its webhooks and holds no token, so it cannot call that server and every manage_pull_request action on it is refused — act on the server directly. `installationStatus` tells a live link from one whose GitHub App was uninstalled or suspended; a repoId from a non-active installation will parse and then fail at the provider call.
manage_pull_request25 of 25 parameters describedCreate, update, merge, close, or request review on pull requests in a linked repository on GitHub or a Forgejo/Gitea server. The repoId picks the provider — get it from list_repositories. Also suggests reviewers ("suggest_reviewers") ranked from CODEOWNERS and file history, on either provider — that action only SUGGESTS; use "request_review" to actually request them. A repository connected in webhook-only mode (Forgejo/Gitea; list_repositories shows `apiAccess: false`) is refused with "this repository is connected in webhook-only mode, so EzModo can't reach its server; act on the server directly". An action the provider cannot do is refused with "<action> isn't supported for <provider> repositories" and `details.code: "capability_unsupported"`.
manage_todo11 of 11 parameters describedCreate, update, complete, or promote personal todos. Todos are lightweight tasks for quick capture that can be promoted to project tasks. create and update take a due date and a reminder: remindAt fires once at a time you give, remindBeforeDue fires that long before the due date and follows it if it moves. Times without an offset ("2026-10-02T09:00") are read in the person's own timezone; the response says which zone was used and warns when none is set and UTC was assumed — tell your person rather than guessing. For something that repeats, use manage_recurring_task.
list_todos1 of 1 parameter describedList personal todos from your todo list. Returns active todos by default.
list_notes3 of 3 parameters describedList the user's personal notes (title, snippet, pin, folder). Notes are the user's PRIVATE scratch notes: personal (never shared with teammates) and cross-org (the same notes whichever organization is active). Use get_note for a note's full markdown content.
get_note1 of 1 parameter describedGet one personal note with its full content as markdown. Checklists are GFM task items (`- [ ] todo`, `- [x] done`). References to tasks, epics, projects or goals are links like `[#Fix login bug](ezmodo://task/<entityId>?org=<orgId>&number=42)`; a promoted reference uses `ezmodo://ref/<type>/<id>?org=<orgId>`. Keep these links unchanged when rewriting a note — removing one removes the reference and its backlink. To add a reference, write the same link with the entity's type, id and organization id. Some notes hold formatting markdown cannot represent (underline, @user mentions, highlight, tables); for those get_note returns markdownLossless: false and their content is an approximation. Check markdownLossless before rewriting a note with manage_note content: when it is false, use append instead. Notes are the user's PRIVATE scratch notes: personal (never shared with teammates) and cross-org (the same notes whichever organization is active).
manage_note14 of 14 parameters describedCreate, edit, move, pin, delete or promote a personal note. Notes are the user's PRIVATE scratch notes: personal (never shared with teammates) and cross-org (the same notes whichever organization is active). Content is markdown. "promote" turns the note into a task, bug or epic in a project of the user's choosing and links the new item back to the note.
manage_note_folder4 of 4 parameters describedList, create, rename, move or delete the folders that organize the user's personal notes (separate from project document folders). Deleting a folder never deletes notes: its notes and subfolders move up to its parent.
manage_test_case31 of 31 parameters describedCreate, update, delete test cases, or record a test run. Test cases belong to projects and define verification criteria with optional structured steps. action "bulk" applies one bulkAction to many cases (caseIds or a filter, max 500); dryRun first.
manage_test_suite44 of 44 parameters describedCreate, update, delete test suites, or add/remove cases from a suite. Suites are project-level groupings of test cases (e.g., regression, smoke, acceptance). Start a run with start_run: suiteId for one suite, suiteIds for a plan run over several (a case in two suites runs once), or caseIds / filter for an ad-hoc run with no suite; plus environment and releaseCandidateId? (ties the run to the build under test so release gates can read it) and assignments to split the cases between people. Then record_result (runId, caseId, overallStatus: pass|fail|skip|blocked) for each case, and complete_run (runId; skipRemaining:true if some cases were not run). suiteId is not needed on record_result or complete_run. List runs with list_test_suites runs:true. import_results records a CI results file (JUnit XML, xUnit v2 XML, or JSON {results:[{key,name,status,durationMs,message}]}) as one completed run with trigger "ci": give filePath (a local file) or content, plus suite (id or slug, optional), environment and commitSha. Each result matches the case whose externalKey equals JUnit classname.name (set it with manage_test_case update externalKey). Unmatched results are returned and kept 30 days. Repeating the same file for the same suite, commit and environment returns the first import (duplicate:true). map_unmatched (key, caseId) maps an unmatched key to a case: it sets the case's externalKey and records the results still kept for that key on the case, each at the time it was uploaded. create_case_from_unmatched (key, name?, caseTitle?, casePriority?, caseCategory?, suiteId?) creates a case for an unmatched key instead (title from the test name when caseTitle is omitted; category regression, persistent), adds it to suiteId (id or slug) if given, then maps the key and records its kept results. import_results with runId records into that open (pending/in_progress) run's cases instead of a new ci run: the run's environment/commit/candidate are used, matched cases not in the run come back in skipped. unmatched:"failures" keeps only failing unmatched results for mapping (unmatchedSkipped counts the rest). Dynamic suites: create/update with membershipRule ({search?, priorities?, categories?, lifecycleStatuses?, retentions?, excludeCaseIds?}; conditions AND, values within one OR) keeps the matching cases as rule members automatically; update with membershipRule:{} clears the rule (hand-added cases stay). preview_rule (rule, suiteId?) shows the match count and sample, and with suiteId what saving would add and remove. reorder_cases (suiteId, cases:[{caseId, position, section?}]) sets order and sections; unlisted cases keep their place. update also takes milestoneId + milestonePriority to gate the suite on a milestone ("" clears).
list_test_cases25 of 25 parameters describedList test cases or get a single test case. Provide testCaseId (+ projectId) for single lookup, or projectId with optional filters for listing. With testCaseId and fixPrompt:true, get the prompt for fixing that case's failure. A list response includes `total` (every case matching the filters) — read it before concluding a case does not exist, since one page holds at most 200.
list_test_suites16 of 16 parameters describedList test suites or get a single test suite. Provide testSuiteId (+ projectId) for single lookup, or projectId with optional filters for listing. With runs:true, list test runs across the project instead — every suite, plan and ad-hoc run, newest first — filtered by runStatus, suiteId, environment, releaseCandidateId, assigneeId and trigger; the response has `total`. With runs:true and runId, get one run with its cases, assignees and results. With testSuiteId and caseOrder:true, get the suite's cases in order with sections and source (manual or rule). With testSuiteId and matrix:true, get each case's result in the suite's latest matrixRuns runs (default 10).
get_testing_summary5 of 5 parameters describedGet aggregate test statistics for a project (or a specific task) including pass/fail counts, coverage, recent run history, and per-environment breakdowns. The project summary also has caseCount (real cases; totalCases counts case x environment), flakyCount/flakyCases and medianRunAgeDays. view "confidence" returns shipping confidence for a release candidate per environment (pass rate, suites run and not run, suite_pass_rate gate status); view "trend" returns daily pass/fail/skip/blocked counts.
get_context11 of 11 parameters describedGet contextual information about any entity (project, task, epic, file, tag). Replaces search_project_context, get_related_files, get_project_overview, get_critical_files, query_project_graph, analyze_impact, get_graph_stats, analyze_project_organization. Use `query` for keyword search, or `entityType` + `entityId` for entity-specific context. Control what's returned via `include` array.
rebuild_manifest2 of 2 parameters describedTrigger regeneration of the project context manifest. "incremental" re-analyzes only files changed since last generation (fast). "full" regenerates everything with static analysis. Needs a local manifest; the result is local only. The API copy is kept current by link_commit and update_manifest_entries.
update_manifest_entries3 of 3 parameters describedWrite AI-enriched summaries to the project's context manifest, which lives in the API. This is the follow-up to manage_task action:"link_commit": its response lists `manifest.needsSummary` — paths the commit added that have no summary yet — so read each one and write a summary here. Entries that do not exist yet are created. Pass `deletes` to remove paths. Marks entries as LLM-enriched; a local manifest file, if the repo has one, gets the same change.
get_manifest_schema2 of 2 parameters describedGet the full context manifest JSON schema with documentation and examples. Use this when you need to generate a manifest for a language or project that the built-in generator doesn't support. The schema includes field descriptions, valid enum values, example entries, and a reusable prompt template for AI agents. Supported natively: TypeScript/JavaScript, Go, Python, Rust, Java, Kotlin, Dart, C#, Swift, PHP, Ruby, C/C++. For any other language, use this schema to generate a valid manifest yourself.
resolve_concepts2 of 2 parameters describedResolve user-facing product terms to code locations. Use this when a user refers to a feature by its product name (e.g., "dashboard", "board", "settings") and you need to find the corresponding code files. Returns matching concept aliases from the manifest, plus get_context results for broader matching.
validate_manifest1 of 1 parameter describedValidate a manifest JSON against the schema. Returns errors and warnings. Use this after generating a manifest to check it before uploading. Checks: required fields, valid enum values, dependency paths exist in manifest, entry count matches metadata, and common issues.
get_project_changes5 of 5 parameters describedGet recent activity and changes for a project. Returns structured events (task created/completed, epic progress, doc updates, etc.) with an aggregate summary. Use this to understand what happened in a project since a given date.
catch_up7 of 7 parameters describedCatch me up: what happened in a project since a date, for YOU to summarise for your person. ezmodo does not write the summary; it hands you the activity grouped by the thing it happened to — one line per task, epic, goal, milestone or document, with its status journey in order (todo → in_progress → completed), what else changed, how many comments, who, and when — most significant first. Built for volume. `totals` always counts the whole window. A small window comes back inline (`items`). A large one, in a checkout, is written to a file under .ezmodo/catch-up/ and you get its path plus the top `highlights`: read the file in chunks as far as you need. Over the remote connector a large window comes back a page at a time: pass `nextCursor` back as `cursor` for the next page. scope "epic" (with epicId) answers for one epic instead, since you last looked, in sentences — it is get_epic_activity. For a sprint, pass the sprint's start date as `since`. For what happened to things you watch, use list_notifications.
manage_fact7 of 7 parameters describedCreate, update, or delete project facts (knowledge entries). Facts are short, tagged knowledge items scoped to a project — useful for capturing decisions, conventions, and reference info that humans and AI agents need.
list_facts2 of 2 parameters describedList all project facts (knowledge entries) for a project. Returns pinned facts first.
list_agent_suggestions6 of 6 parameters describedList pending background-agent suggestions for the current organization. Returns the newest first — review and either accept_agent_suggestion or reject_agent_suggestion each one. Action types: 'link' (create entity_link), 'archive' (set tasks.archived=true), 'unblock_check' / 'enrich' (no destructive side effect on accept — intent only).
accept_agent_suggestion2 of 2 parameters describedAccept a pending suggestion. The framework runs the side effect tied to the suggestion's action (e.g. action='link' inserts the entity_link, action='archive' archives the task) BEFORE flipping the status to accepted, so a failed side effect leaves the suggestion pending.
reject_agent_suggestion0 of 2 parameters describedReject a pending suggestion. Flips status to rejected and frees the dedup slot so the agent may re-propose the same idea in a future run if conditions change. Use a reviewNote to teach future judgement.
run_agent_now1 of 2 parameters describedManually enqueue an agent run, bypassing the scheduler's cadence. Useful for testing or for 'check this entity now' flows. The agent type must be registered server-side. Quota is respected — if the org has exhausted its monthly suggestion cap the run completes with status='quota_exhausted' and zero new suggestions.
configure_agent1 of 3 parameters describedEnable, disable, or change cadence for an agent in the current org. First enable on a fresh org schedules the agent's first run for NOW() so initial suggestions arrive within a scheduler tick (~60s).
resolve_link_suggestions3 of 3 parameters describedAccept and/or reject several pending suggestions in ONE call. This exists because clearing a queue item-by-item costs a call each, and anything that expensive gets skipped — leaving suggestions to pile up until someone bulk-dismisses them unread. Pass the ids you agree with in `accept` and the ones you do not in `reject`. Rejecting is a real answer, not a failure: a rejection with a reason is how the linker learns. Leaving items pending is the only wrong outcome. WHERE THE IDS COME FROM: the `suggestionId` on each entry of a manage_task / manage_epic response's `linkSuggestions`, or — authoritatively — list_agent_suggestions with action:"link" plus entityType/entityId. Prefer list_agent_suggestions when a response says its list may be partial: the engine's semantic rules finish a beat after the deterministic ones, so an inline list can legitimately show fewer than are actually queued. Partial failure is reported per id rather than aborting — one bad id must not cost the rest of the batch.
Tested in a sandbox with an empty environment: no API keys, a throwaway folder, nothing from a real account. A passing test shows the server runs and responds. It is not a security audit.