MCP Server

Wayd provides an MCP (Model Context Protocol) server that lets AI assistants like Claude interact directly with your Wayd instance. The MCP server exposes Wayd's API as structured tools that AI agents can call to read and manage your delivery data.

Package: @wayd/mcp

What Can It Do?

The MCP server exposes more than 250 tools across Wayd's core modules:

Module	Capabilities
PPM	List/view portfolios, programs, projects, stages, tasks. Create and update portfolios, programs, projects, and tasks. Change status (approve, activate, complete, cancel, close, archive). View project plan tree, summary metrics, status history, and activity history. Manage task dependencies. Review and log project health checks. Review project scores and portfolio ranking.
Strategic Initiatives	List/view initiatives, their statuses, activity history, and the projects delivering them. Review KPIs, checkpoints, and the checkpoint plan with health and trend. Record and remove KPI measurements. Change initiative status.
Planning	List/view planning intervals, iterations, objectives, risks, and the activity history of intervals and objectives. Get PI predictability and health reports. Review and log objective health checks. View calendars.
Roadmaps	List/view roadmaps and their items (activities, milestones, timeboxes).
Story Maps	List story maps and read a full map — goals, steps, tasks (with checklists, personas, and work item links), swim lanes, and personas. Create and manage maps: build out goals/steps/tasks, reorder and move cards, manage swim lanes, personas, checklists, and work item links.
Organizations	List/view teams, teams of teams, and users. Review a team's activity history. Grade a team's backlog health. Read team sprint metrics, cadence velocity, and work distribution reports.
Product Catalog	List/view products and their status and activity history. Create, retype, reparent, tag, and delete products. Record and end dependencies between products. Manage product types and tag categories.
Product Delivery	Plan, cut, release, and withdraw versions, releases, and release packages. Record deployments and how they ended. Manage deployment environments. Read the rollout, delivery metrics, and delivery overview.
Delivery Forecasting	Forecast when a work item, PI objective, or project will be done, and how many backlog work items a team finishes by a date.
Imports	Check a CSV file before importing it, then import the rows it checked. Follow import runs and their row outcomes, and stop, resume, or retry a run.

Prerequisites

There are two ways to connect: the hosted endpoint, which the Wayd API serves itself, and the npm package, which runs on your machine.

Hosted endpoint: a Wayd instance with the MCP Server feature flag on, and an assistant that connects to remote MCP servers over HTTP. You can sign in with your Wayd account, so no token is needed, or use a Personal Access Token.
npm package: a running Wayd instance, a Personal Access Token (PAT) created from your profile page, and Node.js 22+ installed on your machine.

Hosted Endpoint (Preview)

The Wayd API also serves MCP itself, at /mcp on the API's address, using Streamable HTTP. It offers the same tools under the same names as the npm package, so skills and prompts written for one work with the other, and it needs no Node.js on your machine. It also offers a few tools the package lacks: partial updates that change only the fields you name, and single-call evidence reads for health checks. Each of the agent skills is served there without installing it, two ways: as an MCP prompt named after the skill (wayd-ppm, wayd-pi, …) that you can pick in a client that lists prompts, and through a skills tool, which the assistant calls on its own. Every tool's description names the skill for its area, so an assistant connected to the hosted endpoint is pointed to that guidance whichever toolsets you chose; whether it reads it is up to the assistant. The npm package will be retired a few weeks after the hosted endpoint is generally available.

An administrator turns it on with the MCP Server feature flag (Settings > System > Feature Flags); while the flag is off, /mcp answers 404. Connect in one of two ways:

Sign in with your Wayd account and approve the assistant. Nothing to create, copy or store, and you can disconnect it from your profile at any time. Use this whenever your assistant supports it.
A Personal Access Token in the x-api-key header, for an assistant that cannot sign in or a script that runs unattended.

Give your assistant the /mcp address and nothing else: no token and no headers. On its first call Wayd answers that you need to sign in, and the assistant opens Wayd in your browser.

Claude Code — add the server, then authenticate from a session:

claude mcp add --transport http wayd https://your-wayd-api.com/mcp

In Claude Code, run /mcp, choose wayd, and choose Authenticate. Or put it in .mcp.json without a headers block:

{
    "mcpServers": {
        "wayd": {
            "type": "http",
            "url": "https://your-wayd-api.com/mcp"
        }
    }
}

VS Code (.vscode/mcp.json):

{
    "servers": {
        "wayd": {
            "type": "http",
            "url": "https://your-wayd-api.com/mcp"
        }
    }
}

claude.ai, ChatGPT and other hosted assistants: add a custom connector and give it the /mcp address. They cannot send a personal access token, so signing in is the only way they connect.

When Wayd opens:

Sign in, if you are not already. You come back to the request afterwards.
Read the connection request. It names the site the application belongs to — that is what identifies it — and the name the application gives itself, which is only its own claim. It also says where you will be sent afterwards, and warns you if that is a different site from the application's.
Choose Approve to let the application use Wayd as you, or Deny to refuse. Either way you are sent back to the application.

An approved application can do anything your account can, with all of your permissions. It appears as a connected application on the Sessions tab of your profile, where you can disconnect it at any time. A request you leave unanswered expires after ten minutes; start again from the application.

A change an application makes through Wayd's tools is recorded as yours, and the Activity of the record it changed names the application it was made through.

The assistant keeps you signed in and renews its access by itself. If it stops working, sign in again from the assistant (in Claude Code, /mcp again).

An assistant can sign in only if it identifies itself the way current MCP clients do, with a Client ID Metadata Document: a public web address describing the assistant. Wayd does not support the older dynamic client registration. If an assistant cannot complete sign-in, connect it with a personal access token instead.

Connecting with a Personal Access Token

Send a Personal Access Token in the x-api-key header. The assistant then skips sign-in and acts with the token's access until you revoke it.

Claude Code (.mcp.json):

{
    "mcpServers": {
        "wayd": {
            "type": "http",
            "url": "https://your-wayd-api.com/mcp",
            "headers": {
                "x-api-key": "your-personal-access-token"
            }
        }
    }
}

VS Code / Cursor (.vscode/mcp.json):

{
    "inputs": [
        {
            "id": "waydApiKey",
            "description": "Wayd API key (Personal Access Token)",
            "type": "promptString",
            "password": true
        }
    ],
    "servers": {
        "wayd": {
            "type": "http",
            "url": "https://your-wayd-api.com/mcp",
            "headers": {
                "x-api-key": "${input:waydApiKey}"
            }
        }
    }
}

Choosing Tools

Every tool's description is loaded into the conversation before any work starts, and all of them together run to about 45,000 tokens. Ask for only the tools your work needs by naming toolsets, and add read-only mode for an assistant that should look but never change anything.

Toolset	Tools
`ppm`	Portfolios, programs, projects, tasks, strategic initiatives
`planning`	Planning intervals, roadmaps, story maps
`products`	Products, product types, tag categories
`delivery`	Versions, releases, release packages, deployments, environments, metrics
`teams`	Teams, teams of teams, users
`work`	Work item forecasts for workspaces
`imports`	Checking, applying and following CSV imports

Choose them on the URL, or in headers if your client sends them:

Query parameter	Header	Effect
`toolsets=ppm,planning`	`X-MCP-Toolsets: ppm,planning`	Only those toolsets. Leave it out, or name `all`, for every toolset.
`readonly=true`	`X-MCP-Readonly: true`	Only tools that read; every create, update and delete is left out.

The query parameter wins when both are sent. An unknown toolset name is refused with 400 rather than ignored, so a typo does not quietly leave you without tools. A tool outside the selection cannot be called either, so read-only mode holds even against an assistant that knows a write tool's name.

{
    "mcpServers": {
        "wayd-planning": {
            "type": "http",
            "url": "https://your-wayd-api.com/mcp?toolsets=planning,teams&readonly=true"
        }
    }
}

Hosted assistants that sign in cannot send headers, so give them the selection on the URL. With a personal access token, add its headers block as usual.

Read-only mode limits which tools are offered, not what your account may do. For a guarantee, also connect as an account that has view permissions only.

The skills tool, Skills_Get, and the skill prompts are offered on every connection, whatever toolsets or read-only mode you chose.

Large Results

A tool's answer is capped at about 20,000 tokens, so one call over a large project cannot fill the conversation. A list longer than that keeps its first items and says which ones it is showing, such as items 1–74 of 843. Tools whose answer is a list take an offset argument, and the note gives the value that continues it, so the assistant can read the rest a part at a time. A tool whose answer is one record holding a list, such as a summary with its work items, takes no offset; the assistant narrows it with the tool's filters (a status, a portfolio, a team) instead.

Hosted-Only Tools

Besides every tool in the tables below, the hosted endpoint offers these:

Tool	Toolset	Description
`Skills_Get`	(every connection)	Read one of the agent skills, or one of its reference files
`Projects_GetHealthCheckEvidence`	`ppm`	Everything needed to recommend a project health check, in one read: the plan summary, overdue tasks, stages past their end, the forecast, the latest check, and activity since it
`PlanningIntervals_GetObjectiveHealthCheckEvidence`	`planning`	Everything needed to recommend a PI objective health check, in one read: schedule, work items and metrics, the forecast, past checks, activity since the last one, and the team's risks
`Portfolios_Patch` / `Programs_Patch` / `Projects_Patch`	`ppm`	Change some of a record's details, roles or strategic themes, leaving the rest as they are
`Projects_PatchStage` / `Tasks_PatchProjectTask`	`ppm`	Change some of a project stage's or task's fields
`Roadmaps_PatchItem`	`planning`	Change some of a roadmap item's fields
`StoryMaps_PatchGoalPersonas` / `StoryMaps_PatchStepPersonas` / `StoryMaps_PatchTaskPersonas`	`planning`	Tag or untag personas on a goal, step or task, keeping the tags it does not name
`Releases_PatchContents`	`delivery`	Add or remove packages and directly carried versions on a release, leaving the rest of its contents
`ReleasePackages_PatchManifest`	`delivery`	Add, change or drop lines in a package's manifest, keeping every line it does not name

The patch tools take a JSON Patch (RFC 6902) and leave alone anything it does not name, so they avoid the whole-record overwrite of the matching update tools.

Setup

Claude Desktop

Add the following to your Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
    "mcpServers": {
        "wayd": {
            "command": "npx",
            "args": ["-y", "@wayd/mcp"],
            "env": {
                "WAYD_API_BASE_URL": "https://your-wayd-instance.com",
                "WAYD_API_KEY": "your-personal-access-token"
            }
        }
    }
}

Claude Code

Add a .mcp.json file to your project root:

{
    "mcpServers": {
        "wayd": {
            "command": "npx",
            "args": ["-y", "@wayd/mcp"],
            "env": {
                "WAYD_API_BASE_URL": "https://your-wayd-instance.com",
                "WAYD_API_KEY": "your-personal-access-token"
            }
        }
    }
}

Or set environment variables in your shell and omit the env block:

export WAYD_API_BASE_URL="https://your-wayd-instance.com"
export WAYD_API_KEY="your-personal-access-token"

VS Code / Cursor

Add to your .vscode/mcp.json or workspace settings:

{
    "inputs": [
        {
            "id": "waydBaseUrl",
            "description": "Wayd API base URL",
            "type": "promptString"
        },
        {
            "id": "waydApiKey",
            "description": "Wayd API key (Personal Access Token)",
            "type": "promptString",
            "password": true
        }
    ],
    "servers": {
        "wayd": {
            "type": "stdio",
            "command": "npx",
            "args": [
                "-y",
                "@wayd/mcp",
                "--base-url",
                "${input:waydBaseUrl}",
                "--api-key",
                "${input:waydApiKey}"
            ]
        }
    }
}

Configuration

The MCP server accepts configuration via environment variables or CLI arguments:

Environment Variable	CLI Argument	Description
`WAYD_API_BASE_URL`	`--base-url`	The base URL of your Wayd API instance
`WAYD_API_KEY`	`--api-key`	Your Personal Access Token

CLI arguments take precedence over environment variables.

Agent Skills

For Claude Code users, nine pre-built skills provide guided workflows:

/wayd-ppm — Portfolio, program, project, and strategic initiative operations, including scoring, health checks, status changes, and tasks
/wayd-pi — Planning intervals, iterations, objectives, and risks
/wayd-products — The product catalog, plus the product types and tag axes it is built from
/wayd-delivery — Releases, versions, release packages, deployments, environments, and delivery metrics
/wayd-roadmaps — Roadmap exploration with activities and milestones
/wayd-story-maps — Story map analysis and management with goals, steps, tasks, swim lanes, and personas
/wayd-teams — Team lookup and resolving team names to IDs, backlog health, delivery forecasts, and team work distribution reports
/wayd-users — User lookup and resolving names to UUIDs for assignees and project roles
/wayd-imports — Loading CSV data: writing a file, checking it with a preflight, importing it, and following import runs

Install the skills:

npx skills add destacey/wayd

Available Tools

Most records expose an activity history: every recorded change, newest first, with who made it and what the value was before and after. A record that existed before Wayd began tracking its changes starts with a baseline entry showing what it looked like at that point. Some changes are listed on more than one record: moving a product under a new parent also appears in the history of both parents, marked as related and naming the product it was made on.

Project Portfolio Management

Tool	Description
`Portfolios_GetPortfolios`	List portfolios with optional status filter
`Portfolios_GetPortfolio`	Get portfolio details by ID or key
`Portfolios_GetPortfolioPrograms`	List programs in a portfolio
`Portfolios_GetPortfolioProjects`	List projects in a portfolio
`Programs_GetPrograms`	List programs with status/portfolio filters
`Programs_GetProgram`	Get program details
`Programs_GetProgramProjects`	List projects in a program
`Projects_GetProjects`	List projects with status/portfolio/role filters, for you or another employee
`Projects_GetProject`	Get project details
`Projects_GetProjectTeam`	Get team members with roles
`Projects_GetProjectStages`	Get all project stages
`Projects_GetProjectStage`	Get one project stage
`Projects_GetProjectPlanTree`	Get full plan as a hierarchical tree (WBS)
`Projects_GetProjectPlanSummary`	Get plan metrics (overdue, due this week, totals)
`Projects_GetStatusHistory`	Get a project's status change history
`Portfolios_GetActivities` / `Programs_GetActivities` / `Projects_GetActivities`	Every recorded change to a portfolio, program, or project, newest first
`Projects_GetMyProjectsSummary`	Your own project involvement, counted by role
`Projects_GetMyProjectsTaskMetrics`	Your open task counts (overdue, due this week, upcoming)
`Projects_GetTaskMetrics`	Open task counts for you or, with `employeeId`, for a colleague
`Projects_GetProjectsPlanSummaries`	Plan metrics for many projects in one call
`Projects_GetProjectHealthChecks`	Get the health check history for a project
`Projects_GetProjectHealthCheck`	Get a specific project health check by ID
`Projects_CreateProjectHealthCheck`	Log a new health check (Healthy / AtRisk / Unhealthy) on a project
`Projects_UpdateProjectHealthCheck` / `Projects_DeleteProjectHealthCheck`	Correct or remove a recorded health check
`Projects_GetScoringContext` / `Projects_GetScores` / `Projects_GetScore`	Review a project's scoring model and score history
`Portfolios_GetRankingScoreboard`	Score breakdown behind a portfolio's ranking board
`Portfolios_Create` / `Portfolios_Update`	Create and update portfolios
`Programs_Create` / `Programs_Update`	Create and update programs
`Projects_Create` / `Projects_Update`	Create and update projects
`Projects_ChangeProgram` / `Projects_ChangeKey`	Move a project between programs, or change its key
`Portfolios_Activate` / `Portfolios_Close` / `Portfolios_Archive`	Change portfolio status
`Programs_Activate` / `Programs_Complete` / `Programs_Cancel`	Change program status
`Projects_Approve` / `Projects_Activate` / `Projects_Complete` / `Projects_Cancel`	Change project status
`Projects_RevertStatus`	Move a project backwards to an earlier status — reopening a completed one, or returning an active one to approved
`Projects_GetWorkItems`	Get the work items linked to a project
`Projects_GetForecast`	Forecast when a project's work items will be done, and the chance of finishing by its planned end
`ProjectLifecycles_GetProjectLifecycles`	List lifecycles with state filter
`ProjectLifecycles_GetProjectLifecycle`	Get lifecycle details
`ExpenditureCategories_GetOptions`	Resolve the expenditure category needed to create a project
`Portfolios_GetPortfolioOptions`	Lightweight portfolio list (id and name) for lookups
`Portfolios_GetPortfolioStatuses` / `Programs_GetProgramStatuses` / `Projects_GetStatuses`	Resolve the status values each record accepts

Strategic Initiatives

Tool	Description
`StrategicInitiatives_GetStrategicInitiatives`	List initiatives with status/portfolio filters
`StrategicInitiatives_GetStrategicInitiative`	Get initiative details
`StrategicInitiatives_GetStatuses`	Resolve initiative status values
`StrategicInitiatives_GetActivities`	Every recorded change to an initiative, including its KPIs and measurements
`StrategicInitiatives_GetProjects`	Projects delivering an initiative
`Portfolios_GetPortfolioStrategicInitiatives`	Initiatives in a portfolio
`StrategicInitiatives_GetKpis` / `StrategicInitiatives_GetKpi`	Review an initiative's KPIs
`StrategicInitiatives_GetKpiCheckpoints`	A KPI's dated targets
`StrategicInitiatives_GetKpiCheckpointPlan`	Checkpoints with measurements, health, and trend
`StrategicInitiatives_GetKpiMeasurements`	A KPI's measurement history
`StrategicInitiatives_AddKpiMeasurement` / `StrategicInitiatives_RemoveKpiMeasurement`	Record or remove a KPI measurement
`StrategicInitiatives_Approve` / `StrategicInitiatives_Activate` / `StrategicInitiatives_Complete` / `StrategicInitiatives_Cancel`	Change initiative status

Tasks

Tool	Description
`Tasks_GetProjectTasks`	List tasks with status/parent filters
`Tasks_GetProjectTask`	Get task details
`Tasks_GetCriticalPath`	Get critical path task IDs. Not implemented yet: it always returns an empty list
`Tasks_CreateProjectTask`	Create a new task or milestone
`Tasks_UpdateProjectTask`	Update task fields
`Tasks_DeleteProjectTask`	Delete a task
`Tasks_AddTaskDependency`	Add finish-to-start dependency
`Tasks_RemoveTaskDependency`	Remove a dependency
`Tasks_GetTaskTypes` / `Tasks_GetTaskStatuses` / `Tasks_GetTaskPriorities`	Resolve the type, status, and priority values a task accepts

Planning

Tool	Description
`PlanningIntervals_GetList`	List all planning intervals
`PlanningIntervals_GetPlanningInterval`	Get PI details
`PlanningIntervals_GetActivities` / `PlanningIntervals_GetObjectiveActivities`	Every recorded change to a PI, or to one of its objectives
`PlanningIntervals_GetCalendar`	Get PI calendar
`PlanningIntervals_GetPredictability`	Get predictability scores
`PlanningIntervals_GetTeams`	Get teams in a PI
`PlanningIntervals_GetIterations`	Get iterations
`PlanningIntervals_GetIteration`	Get one iteration
`PlanningIntervals_GetObjectives`	Get team objectives
`PlanningIntervals_GetObjective`	Get one objective
`PlanningIntervals_GetRisks`	Get risks
`PlanningIntervals_GetObjectivesHealthReport`	Get health report for all objectives in a PI
`PlanningIntervals_GetObjectiveHealthChecks`	Get the health check history for a PI objective
`PlanningIntervals_GetObjectiveHealthCheck`	Get a specific PI objective health check by ID
`PlanningIntervals_CreateObjectiveHealthCheck`	Log a new health check (1=Healthy, 2=AtRisk, 3=Unhealthy) on a PI objective
`PlanningIntervals_GetTeamPredictability`	Predictability for one team in a PI
`PlanningIntervals_GetIterationCategories`	Resolve iteration category values
`PlanningIntervals_GetIterationSprints`	Sprints within an iteration
`PlanningIntervals_GetIterationMetrics`	Iteration metrics
`PlanningIntervals_GetIterationBacklog`	An iteration's backlog
`PlanningIntervals_GetObjectiveStatuses`	Resolve objective status values
`PlanningIntervals_GetObjectiveWorkItems` / `PlanningIntervals_GetObjectiveWorkItemMetrics`	Work items behind an objective, and their metrics
`PlanningIntervals_GetObjectiveForecast`	Forecast when an objective's work items will be done, and the chance of finishing by its target date
`Roadmaps_GetRoadmaps`	List all roadmaps
`Roadmaps_GetRoadmap`	Get roadmap details
`Roadmaps_GetItems`	Get all roadmap items
`Roadmaps_GetItem`	Get roadmap item details
`Roadmaps_GetActivities`	List a roadmap's activities (the timed items on it, not its change history)
`Roadmaps_GetVisibilityOptions`	Resolve roadmap visibility values

Story Maps

Tool	Description
`StoryMaps_GetStoryMaps`	List story maps (optionally including archived)
`StoryMaps_GetStoryMap`	Get a full story map — goals, steps, tasks, swim lanes, personas
`StoryMaps_CreateStoryMap`	Create a story map
`StoryMaps_UpdateStoryMap`	Update a map's name and description
`StoryMaps_ChangeStoryMapOwner`	Change the map's owner
`StoryMaps_ArchiveStoryMap`	Archive a story map
`StoryMaps_DeleteStoryMap`	Permanently delete a story map
`StoryMaps_AddGoal`	Add a goal (created with one step)
`StoryMaps_RenameGoal` / `StoryMaps_ReorderGoal` / `StoryMaps_DeleteGoal`	Manage goals
`StoryMaps_AddStep`	Add a step to a goal
`StoryMaps_RenameStep` / `StoryMaps_ReorderStep` / `StoryMaps_MoveStep` / `StoryMaps_DeleteStep`	Manage steps
`StoryMaps_AddTask`	Add a task to a step (defaults to the default swim lane)
`StoryMaps_UpdateTask` / `StoryMaps_MoveTask` / `StoryMaps_DeleteTask`	Manage tasks
`StoryMaps_AddChecklistItem` / `StoryMaps_RenameChecklistItem` / `StoryMaps_SetChecklistItemChecked` / `StoryMaps_RemoveChecklistItem`	Manage a task's checklist
`StoryMaps_PromoteChecklistItem`	Promote a checklist item into a task
`StoryMaps_LinkWorkItem` / `StoryMaps_UnlinkWorkItem`	Link/unlink a task to a work item
`StoryMaps_AddSwimLane` / `StoryMaps_RenameSwimLane` / `StoryMaps_SetSwimLaneDates` / `StoryMaps_ReorderSwimLane` / `StoryMaps_RemoveSwimLane`	Manage swim lanes
`StoryMaps_AddPersona` / `StoryMaps_UpdatePersona` / `StoryMaps_ReorderPersona` / `StoryMaps_DeletePersona`	Manage personas
`StoryMaps_SetGoalPersonas` / `StoryMaps_SetStepPersonas` / `StoryMaps_SetTaskPersonas`	Set persona tags on a node

Product Catalog

The catalog is one typed tree of what your organization owns — products, platforms, services, and tools. A product's type carries the flag that decides whether versions can be cut against it, which is why a product line usually holds no versions of its own.

Tool	Description
`Products_GetProducts`	List products, filtered by parent, type, status category, or tags
`Products_GetProduct`	Get product details
`Products_GetStatusHistory`	A product's status change history
`Products_GetActivities`	Every recorded change to a product
`Products_GetStatusOptions`	Resolve the status values a product accepts
`Products_Create` / `Products_Update`	Create a product, or change its name and description
`Products_Retype`	Change a product's type
`Products_Reparent`	Move a product beneath a different parent
`Products_ChangeStatus`	Change a product's status
`Products_LinkExternally`	Link a product to an external system
`Products_Tag` / `Products_Untag`	Apply or remove a tag
`Products_GetDependencies`	What a product depends on and what depends on it, rolled up across everything beneath it
`Products_AddDependency` / `Products_UpdateDependency`	Record that a product depends on another, or reword what it is for
`Products_ChangeDependencyTerms`	Change a dependency's strength or interaction styles — ends it and opens a new one
`Products_EndDependency` / `Products_RemoveDependency`	Record that a dependency stopped (kept), or delete one recorded by mistake
`Products_Delete`	Permanently delete a product
`ProductTypes_GetProductTypes`	List the types a product can be, and whether each allows versions
`ProductTypes_Create` / `ProductTypes_Update` / `ProductTypes_Delete`	Manage product types
`ProductTypes_SetActive`	Take a type out of use, or put it back
`ProductTagCategories_GetProductTagCategories`	List the tag axes and their tags
`ProductTagCategories_Create` / `ProductTagCategories_Update` / `ProductTagCategories_Delete`	Manage tag axes
`ProductTagCategories_SetActive`	Take an axis out of use, or put it back
`ProductTagCategories_Reorder`	Reorder the axes — the list must name every one exactly once
`ProductTagCategories_AddTag` / `ProductTagCategories_RenameTag`	Manage the tags on an axis
`ProductTagCategories_SetTagActive`	Take a single tag out of use, or put it back
`ProductTagCategories_DeleteTag`	Permanently delete a tag no product carries

Dependencies are rolled up: a product line's list includes its services' links to anything outside it. Strength has no default — hard if the product stops working without the other, soft if it only degrades — and a dependency that stopped should be ended, not removed, so the record of when it held survives.

Three behaviours worth knowing. Tagging an axis that only allows one value silently replaces the existing tag rather than refusing. Deleting a product is a hard delete, refused while anything depends on it. And seeded system types and axes cannot be edited or deleted, but can be deactivated — so an organization can hide a type it doesn't use. Individual tags inside a seeded axis are the exception: they can't be deactivated either, so retire the whole axis instead.

Product Delivery

Where the catalog records what exists, delivery records what shipped. The word "release" means three different things in most organizations, and Wayd keeps them apart: a release is what was announced to customers (Wayd 2026.07), a version is one artifact that was built (Wayd API 4.12.0), a package is what moved through environments together (WAYD-2026.07), and a deployment is one of those reaching one environment.

Tool	Description
`Releases_GetReleases` / `Releases_GetRelease`	List releases, or get one
`Releases_GetStatusHistory`	A release's status change history
`Releases_GetActivities`	Every recorded change to a release
`Releases_Plan` / `Releases_Update`	Plan a release, or update its details
`Releases_SetContents`	Set what the release announces — its versions and packages together
`Releases_MarkReleased`	Announce a release
`Releases_Withdraw` / `Releases_Revert`	Withdraw a release, or revert it to an earlier state
`Releases_Delete`	Permanently delete a release; the versions and packages it listed are kept
`Releases_CorrectDates` / `Releases_MoveTargetDate`	Correct recorded dates, or move the target
`Versions_GetVersions` / `Versions_GetVersion`	List versions, or get one
`Versions_GetStatusHistory`	A version's status change history
`Versions_GetActivities`	Every recorded change to a version
`Versions_Plan` / `Versions_Update`	Plan a version, or update its details
`Versions_Cut`	Cut the version — the artifact now exists
`Versions_MarkReleased`	Mark a version released
`Versions_Withdraw` / `Versions_Revert`	Withdraw a version, or revert it
`Versions_Delete`	Permanently delete a version and every deployment of it
`Versions_CorrectDates` / `Versions_MoveTargetDate`	Correct the target date or the cut/released moments, or move the target
`ReleasePackages_GetReleasePackages` / `ReleasePackages_GetReleasePackage`	List packages, or get one
`ReleasePackages_GetStatusHistory`	A package's status change history
`ReleasePackages_GetActivities`	Every recorded change to a package
`ReleasePackages_Assemble`	Assemble a package
`ReleasePackages_SetManifest`	Replace what the package contains
`ReleasePackages_MarkReleased` / `ReleasePackages_Withdraw`	Mark a package released, or withdraw it
`ReleasePackages_CorrectDates`	Correct a package's recorded target date or released moment
`ReleasePackages_Delete`	Permanently delete a package, its manifest and every deployment of it
`Deployments_GetDeployments` / `Deployments_GetDeployment`	List deployments, or get one
`Deployments_GetStatusHistory`	A deployment's status change history
`Deployments_GetActivities`	When a deployment started and how it ended
`Deployments_Start`	Record a deployment starting — of a version or a package, never both
`Deployments_Succeed` / `Deployments_Fail` / `Deployments_RollBack`	Record how a deployment ended
`Deployments_Delete`	Permanently delete a deployment and its status history
`DeploymentEnvironments_GetDeploymentEnvironments`	List environments, by active state or category
`DeploymentEnvironments_Create` / `DeploymentEnvironments_Update`	Define or edit an environment
`DeploymentEnvironments_SetActive`	Retire an environment, or reinstate it
`DeploymentEnvironments_Delete`	Permanently delete an environment and every deployment into it
`DeploymentEnvironments_GetRollout`	What is running in each environment now, in rollout order
`DeliveryMetrics_GetDeliveryMetrics`	Deployment frequency and change failure rate over a window
`DeliveryOverview_GetDeliveryOverview`	Version activity over a window — release frequency and cut-to-released time, for a product and everything beneath it
`DeliveryOverview_GetRecentDeliveryEvents`	What has happened to versions and packages lately

Contents and manifests replace as a set. Releases_SetContents and ReleasePackages_SetManifest overwrite what was there, so send the full list including anything that should stay.

Environments are retired rather than deleted, because historical deployments still point at them — deleting one takes every deployment into it along. Every production-scoped measure counts on an environment's category, not its name — pipeline names vary too much (prod, prd, live) to reason about. Reclassifying an environment changes where future deployments count and leaves past ones alone.

DeliveryMetrics_GetDeliveryMetrics returns an unavailable list naming what it couldn't compute and why; read it rather than treating a missing measure as zero. Change failure rate is a proxy — a pipeline run that failed before production is a failure that was prevented, while a real change failure succeeded and then broke something, which the pipeline can't know.

DeploymentEnvironments_GetRollout reports the latest deployment of each product that succeeded and wasn't rolled back, so a failed attempt leaves its predecessor listed as running — and flags that a later attempt failed. DeliveryOverview_GetDeliveryOverview measures versions rather than deployments, so it answers how often you ship even where pipelines aren't recorded in Wayd. Pass an IANA timeZone (default UTC) so the window and its per-day buckets are the caller's own days; cut-to-released is the elapsed time between the two moments, in fractional days.

Organization

Tool	Description
`Teams_GetTeams`	List teams with optional inactive filter
`Teams_GetTeam`	Get team details
`Teams_GetActivities`	Every recorded change to a team
`Teams_GetBacklogHealth`	Grade a team's backlog and list the work items each check flagged, with optional what-if thresholds
`Teams_GetThroughputForecast`	Forecast how many backlog work items a team finishes by a date, and which work item that reaches
`Teams_GetSprintMetrics`	Team sprint metrics: average velocity, predictability and say/do over a team's last sprints, with each sprint's values
`Teams_GetCadenceMetrics`	Cadence velocity: a Kanban team's completed work in each period of its reporting cadence, with the average and spread
`Teams_GetTeamWorkDistribution`	Work Distribution report showing where a team's completed work went over a date range
`TeamsOfTeams_GetList`	List teams of teams with optional inactive filter
`TeamsOfTeams_GetWorkDistribution`	Work Distribution report rolling up completed work across a team of teams hierarchy
`Workspaces_GetWorkItemForecast`	Forecast when a work item will be done, from its team's throughput, backlog position and predecessors
`Users_GetUsers`	List all users
`Users_GetUser`	Get user details

Imports

Every CSV file submitted to Wayd becomes a run with an outcome for each row — whether it was submitted from Settings → System → Imports or straight to the API — so these tools can follow and control either. You see the kinds of import you are allowed to submit.

Tool	Description
`Imports_GetDefinitions`	The kinds of import you may see, with their row limits and whether you may submit them
`Imports_GetFileFormat`	The columns a kind of import's CSV files must carry, and the values each accepts
`Imports_Preflight`	Check a CSV file against your data without importing anything
`Imports_GetList`	Import runs, newest first, filtered by status, kind, submitter, or submission group
`Imports_GetById`	One run's status and counts
`Imports_GetRows`	A run's row outcomes, with the reason each rejected row was refused
`Imports_Cancel`	Stop a run that is still going — rows already applied stay applied
`Imports_Resume` / `Imports_RetryFailed`	Queue a finished run again for the rows it never reached, or for its rejected rows too
`Imports_Apply`	Import the rows a preflight checked

Your assistant can't import a file in one step. It first runs a preflight, which checks every row the way a real import would and creates nothing, then shows you what would be imported and what would be refused. Only then can it import those rows with Imports_Apply, which asks for confirmation. A preflight reports what would have happened when it ran; each row is checked again when it is imported.

Changes That Ask First

Most tools only read data. The ones that change something a colleague relies on — changing a record's status, updating a portfolio, program, or project, deleting anything, or importing, stopping, or re-running an import — are flagged so your AI assistant asks for confirmation before running them.

Whether you actually see a prompt depends on the assistant you're using: the flag is a signal, and clients decide how to honour it. Your permissions are always enforced by Wayd itself regardless of what any client does.

Two behaviours worth knowing before you approve one:

Updates replace the whole record. Anything not included in an update is cleared rather than left alone. This matters most for people: sponsors, owners, managers, and members are replaced as a set, so an update must carry the full team to keep it. Your assistant is instructed to read a record before updating it and pass back everything that should stay the same.
Activating a portfolio sets its start date to today, and closing it sets its end date to today. Neither can be backdated, so avoid using them to tidy up a portfolio that really started or ended earlier.

Deleting a portfolio, program, project, or strategic initiative isn't available through the MCP server at all.

Security

Whichever way you connect, the assistant acts as you, with your permissions — it can only access what you can access.

Signed in: nothing is stored in your configuration. Disconnect an assistant from the Sessions tab of your profile and it loses access at once.
Personal access token: store it securely, never commit it to version control, and prefer environment variables or a client's password prompt over hardcoding it in config files. Revoke it from your profile page if it is exposed.

Changing a portfolio, program, or project additionally requires delivery leadership — being an Owner or Manager on the record or on one above it. Having permission to view or edit is not enough on its own, and sponsors and project members are excluded. If a change is refused even though you have the right permission, this is usually why. See Permissions for details.

What Can It Do?​

Prerequisites​

Hosted Endpoint (Preview)​

Connecting with Sign-In​

Connecting with a Personal Access Token​

Choosing Tools​

Large Results​

Hosted-Only Tools​

Setup​

Claude Desktop​

Claude Code​

VS Code / Cursor​

Configuration​

Agent Skills​

Available Tools​

Project Portfolio Management​

Strategic Initiatives​

Tasks​

Planning​

Story Maps​

Product Catalog​

Product Delivery​

Organization​

Imports​

Changes That Ask First​

Security​