Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@microsoft-tasks-mcp what do I have to do today across To Do and Planner?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
In one sentence: an MCP server that lets AI coding agents read your Microsoft Planner + Microsoft To Do tasks across all M365 tenants you sign into, without bypassing Microsoft's auth and without ever modifying tasks the agent didn't create itself.
You work across multiple Microsoft 365 tenants — consultancy, customer engagements, your own org. Tasks are scattered across:
Microsoft To Do — your personal task lists, the place flagged emails land, the place ad-hoc reminders go.
Microsoft Planner — group-scoped boards, one per M365 group / Team, where collaborative work lives.
Surfacing "what do I have to do today" already requires the user to mentally union both surfaces. Worse, popular AI agents that can talk to Microsoft 365 either:
bypass Microsoft's modern auth (broken attribution),
can't see the multi-tenant boundary,
or auto-modify tasks created by other people (terrifying).
mcp-server-microsoft-tasks fixes all three: local process per tenant, multi-profile, Microsoft Graph for full attribution, read-only by default, writes opt-in (v0.2+), agent-created-only. The per-profile registry is the hard gate — write tools refuse to touch any task whose ID isn't in the registry of "tasks this profile created".
Sister project to mcp-server-sharepoint and mcp-server-outlook. Same authorship pattern, same auth shape (mcp-microsoft-graph-auth), different surface.
Related MCP server: Microsoft Planner MCP
pip install mcp-server-microsoft-tasks
# or, with uv (recommended):
uv tool install mcp-server-microsoft-tasks
# or, on the fly without installing globally:
uvx mcp-server-microsoft-tasks --helpRequires Python 3.11+. Works on Linux, macOS, Windows.
uvx mcp-server-microsoft-tasks login --account-type work_or_school
# or, for a personal Microsoft account:
uvx mcp-server-microsoft-tasks login --account-type personalThe --account-type flag is required: work_or_school for any Microsoft 365 tenant account (both Planner and To Do work), personal for outlook.com / hotmail.com / live.com / msn.com (only To Do works — Planner needs a work/school M365 group). Internally this picks the right Microsoft Identity Device Code authority (/organizations vs /consumers); TASKS_TENANT_ID is kept as a power-user / CI escape hatch.
The output renders the device code first in its own code block, the URL second on its own line. Copy the code, click the link, paste, sign in. Your refresh token is cached locally (OS keyring on macOS / Windows / Linux desktop; encrypted-file fallback otherwise). The MCP server itself never blocks for human interaction afterwards.
When used through an MCP tool (tasks_login_begin), the agent receives the same account_type requirement via tool-schema description; calling without it returns a structured LoginAccountTypeRequiredError that instructs the agent to ask the user which account kind to sign in with.
In your project's .mcp.json:
{
"mcpServers": {
"microsoft-tasks": {
"command": "uvx",
"args": ["mcp-server-microsoft-tasks"]
}
}
}Restart Claude Code. The agent now has the full v0.1 read surface (see below). All v0.1 tools are read-only — the consent screen on sign-in shows Tasks.Read and Group.Read.All, no write scopes.
uvx mcp-server-microsoft-tasks login --profile customer-acmeThen run a second MCP server process pointed at that profile:
{
"mcpServers": {
"microsoft-tasks-acme": {
"command": "uvx",
"args": ["mcp-server-microsoft-tasks"],
"env": { "TASKS_PROFILE": "customer-acme" }
}
}
}Each profile is one tenant. No cross-tenant token sharing.
Concrete dialogue showing the headline workflow on the v0.1 read surface:
You: What do I have to do today across To Do and Planner?
Agent: [calls tasks_assigned_to_me(include_completed=False, limit=20)]
Five items on your plate, sorted by due date:
Today
- "Review draft contract for Acme" (Planner / Sprint 5 / Todo bucket)
due today, 17:00 — assigned to you + 1 other
- "Pick up dry cleaning" (To Do / Personal)
no time set
Tomorrow
- "Send follow-up to vendor" (Planner / Customer ops / Doing bucket)
due tomorrow, 09:00
Later this week
- "Renew passport" (To Do / Personal) — Friday
- "ISO 27001 control review" (Planner / Compliance / Todo)
Sunday — high priority
You: What's the deal with the ISO control review? Search my tasks for "27001".
Agent: [calls tasks_search("27001", source="all")]
Three matches — one Planner, two To Do:
- "ISO 27001 control review" (Planner / Compliance, due Sunday)
→ bucket "Todo", priority high, no checklist yet
- "Read ISO 27001:2022 changes" (To Do / Reading list, no due date)
- "Schedule auditor call re: ISO 27001 surveillance" (To Do, completed last week)
Want me to pull the full body and checklist of the Planner one?
You: Yes please.
Agent: [calls planner_task_get(task_id="...", include_details=True)]
"ISO 27001 control review" — full description:
Quarterly review of all 93 controls in Annex A. Walk through
the SoA spreadsheet, flag any controls whose ownership has
changed, attach evidence links from SharePoint.
Checklist (4 of 12 done):
- [x] Pull current SoA from SharePoint
- [x] Identify controls touching authentication
- [ ] Map to MFA rollout milestone (still open)
- [ ] ...Every action above is a read — no Planner/To-Do state was modified. The server's default install requests no write scopes; the consent screen reads "this app can read your tasks", not "modify". Write tools (create / update / complete / delete) land in v0.2 behind the explicit TASKS_ALLOW_WRITES=true env flag.
A second dialogue showing v0.2 write tools (TASKS_ALLOW_WRITES=true). Note that the agent only ever creates tasks; it never marks anyone else's task done.
You: I just got out of the steering meeting with the ISMS team. Three follow-ups
— please add them to the Compliance Planner plan, Todo bucket. Owner:
me. Due Friday. The items are:
1. Update the Statement of Applicability for control A.5.1
2. Schedule the Q3 surveillance audit pre-call with the auditor
3. Send the policy-review reminder to the legal team
Agent: [calls planner_plans()]
[calls planner_buckets("Compliance-plan-id") to find the Todo bucket]
[calls planner_task_create x3, each with plan_id + bucket_id + title +
due_date + assignees=["d.koller@xmv.de"]]
Created three Planner tasks in Compliance / Todo, all due Friday:
- "Update SoA for A.5.1" — task id task-abc1
→ https://tasks.office.com/<tenant>/Home/Task/task-abc1
- "Schedule Q3 surveillance pre-call with auditor" — task-abc2
→ https://tasks.office.com/<tenant>/Home/Task/task-abc2
- "Send policy-review reminder to legal" — task-abc3
→ https://tasks.office.com/<tenant>/Home/Task/task-abc3
All three are now in this MCP profile's registry, so I can update or
complete them later if you ask. Want me to also drop a "review the SoA
edits" reminder on your personal To Do list?
You: Yes please, due Thursday.
Agent: [calls todo_task_create(list_id=<default>, title=..., due_date="2026-08-13",
importance="high")]
Added to your default Tasks list:
- "Review the SoA edits before sending" — due Thursday, importance high
You: Mark task-abc3 as complete — I already pinged legal directly.
Agent: [calls planner_task_complete("task-abc3")]
Marked "Send policy-review reminder to legal" complete. The task was in
my registry (I created it earlier this conversation), so the action went
through. If you'd asked me to mark a task you or a colleague had created,
I would have refused — only my own tasks are eligible.The last exchange shows the load-bearing safety guarantee in action. The per-profile registry on disk (~/.cache/mcp-server-microsoft-tasks/<profile>/tasks.json) lists every task this MCP server created. planner_task_update, _complete, and _delete consult that registry before hitting Microsoft Graph and refuse with NOT_OWNED_BY_PROFILE if the task isn't there. ETag-based optimistic concurrency adds a second guard against silently clobbering external edits — see docs/app-concept.md § Conflict / safety semantics.
Tool | What it does |
| Non-blocking Device Code login as MCP tools — agent surfaces code + URL without leaving the chat. |
| Enumerate / fetch Microsoft To Do lists (default Tasks list, flagged-emails list, user-created lists). |
| List / fetch tasks within a To Do list. |
| Enumerate Planner plans across the user's M365 groups (or within one group via |
| List buckets (columns) within a Planner plan. |
| List / fetch Planner tasks. |
| Unified across To Do + Planner. Sorted by due date ascending. |
| Cross-source substring search; |
| Incremental Planner diff since last poll — returns |
Every tool returns a unified task envelope with id, title, status, due_date, assignees, web_url, source, etag, plus source-specific extras (list_id / body_preview / categories / importance / reminder_date for To Do; plan_id / bucket_id / priority / percent_complete / applied_categories for Planner). Agents can route follow-up calls correctly off the source tag without learning two response shapes.
tasks_changes_sincetasks_changes_since(scope, max_results=200) lets an agent detect what changed since it last looked — without re-processing every task on every poll.
Pass a scope dict to control which tasks are polled:
Scope | What gets polled |
| All tasks in one Planner plan ( |
| Tasks assigned to the signed-in user ( |
| Only tasks this MCP profile created — one |
The tool returns:
{
"added": [<task envelope>, ...],
"modified": [<task envelope>, ...],
"removed": [{"id": "...", "last_known_title": null}, ...],
"cursor_advanced": true
}On the first call for a scope, every visible task is returned as added and the cursor is initialised. On subsequent calls, only tasks that appeared, had their lastModifiedDateTime advance, or disappeared from the response are returned. Everything else comes back empty.
The cursor file lives at ~/.cache/mcp-server-microsoft-tasks/<profile>/cursors.json (mode 0o600) and is updated atomically on every call. Each scope is tracked independently (keyed by sha256 of the JSON-serialised scope). The last_modified_max watermark is monotonic — a temporarily stale Graph timestamp can never roll the cursor backwards.
TASKS_ALLOW_WRITES=trueTool | What it does |
| Writes on To Do tasks — only tasks this profile's registry created. |
| Writes on Planner tasks — same registry guarantee. |
| Attach / detach an HTTP/HTTPS URL reference (OneNote, SharePoint, etc.) on a profile-owned Planner task. Same registry guarantee. |
| Inspect this profile's "I created this" registry. |
To enable, set TASKS_ALLOW_WRITES=true in the MCP client config (e.g. via env block in .mcp.json):
{
"mcpServers": {
"microsoft-tasks": {
"command": "uvx",
"args": ["mcp-server-microsoft-tasks"],
"env": { "TASKS_ALLOW_WRITES": "true" }
}
}
}The default install does NOT request Tasks.ReadWrite. Setting TASKS_ALLOW_WRITES=true adds the scope at sign-in time AND registers the write tools at MCP-server-start time.
Per-profile registry on disk records every task this server created (~/.cache/mcp-server-microsoft-tasks/<profile>/tasks.json, mode 0o600). Write tools refuse — at the tool layer, before any Microsoft Graph call — to act on tasks not in the registry. The error is NOT_OWNED_BY_PROFILE. Hand-created tasks in Microsoft Planner / To Do are never modified by the agent; tasks created by other agents (different MCP profile, different process, different machine) are likewise untouchable.
ETag-based optimistic concurrency via If-Match. The registry stores the last ETag this server saw; every PATCH / DELETE attaches it; Microsoft Graph returns 412 Precondition Failed if the task changed externally between the agent's read and the write. The MCP surfaces this as EXTERNALLY_MODIFIED so the agent re-fetches and decides.
No bulk operations, no auto-assignment to other users, no plan/list creation: each write tool acts on exactly one task per call, and assignees on planner_task_create is filled only from values the human typed in chat. See docs/app-concept.md § Conflict / safety semantics.
MS_TASKS_NO_PLANNER=trueMicrosoft Planner requires the Group.Read.All Graph scope to enumerate the M365 groups that own plans. That scope is admin-consent in most tenants — a non-admin user signing in for the first time will hit a "your administrator must approve this app" prompt.
If you only care about your personal Microsoft To Do tasks, opt out of Planner entirely:
{
"mcpServers": {
"microsoft-tasks": {
"command": "uvx",
"args": ["mcp-server-microsoft-tasks"],
"env": { "MS_TASKS_NO_PLANNER": "true" }
}
}
}With this flag set:
The OAuth scope request drops Group.Read.All, so the consent screen no longer needs admin approval.
The MCP server skips registering all planner_* tools at start-up (so the agent never sees them).
tasks_assigned_to_me and tasks_search silently exclude the Planner half — they still work, just on the To Do side only.
Both the writes opt-in (TASKS_ALLOW_WRITES=true) and the no-Planner opt-out are independent: you can have writes-with-Planner, writes-without-Planner, reads-with-Planner, or reads-without-Planner.
/beta with MS_TASKS_PLANNER_BETA=trueMicrosoft Graph's Planner recurrence APIs are /beta-only. To create a recurring task — or to see the recurrence field on read — opt in to the beta endpoint:
{
"mcpServers": {
"microsoft-tasks": {
"command": "uvx",
"args": ["mcp-server-microsoft-tasks"],
"env": { "TASKS_ALLOW_WRITES": "true", "MS_TASKS_PLANNER_BETA": "true" }
}
}
}With the flag on, every Planner tool routes through /beta/planner/.... planner_task_create and planner_task_update accept an optional recurrence argument; the unified envelope surfaces recurrence on read with the schedule + series-tracking metadata Graph populates.
Example agent call (creating a weekly status-update task):
{
"tool": "planner_task_create",
"arguments": {
"plan_id": "...", "bucket_id": "...", "title": "Weekly status",
"recurrence": {
"schedule": {
"patternStartDateTime": "2026-05-11T08:00:00Z",
"pattern": {
"type": "weekly", "interval": 1,
"daysOfWeek": ["monday"], "firstDayOfWeek": "sunday"
}
}
}
}
}To stop a series: planner_task_update(task_id, recurrence={"schedule": null}). (Graph rejects setting top-level recurrence to null on a task that already has it.) Without the flag, passing a recurrence argument raises before the HTTP call with a clear pointer to MS_TASKS_PLANNER_BETA.
mcp-server-microsoft-tasks uses mcp-microsoft-graph-auth (sister library) to manage tokens. Default backend on macOS / Windows / Linux-desktop is the OS keyring; on headless Linux the fallback is a 0600 plain file at ~/.cache/mcp-server-microsoft-tasks/<profile>/token.json. For CI / encrypted-file mode, set MS_TASKS_TOKEN_PASSPHRASE and MS_TASKS_TOKEN_STORE=encrypted-file. Override the auto-pick with MS_TASKS_TOKEN_STORE=keyring|file|encrypted-file.
Document | Description |
Vision, tool surface, auth model, conflict semantics, Testability section | |
XMV's project-agnostic baseline (test layers, source-control, PR discipline) | |
Brief for AI coding agents — project facts, tech stack, behaviour rules | |
What the OAuth app sees, what XMV sees (nothing), GDPR pointers | |
Default OAuth app, BYO override, disclaimer | |
Contribution flow | |
Vulnerability disclosure | |
Keep-a-changelog history |
Dual-licensed under either of:
Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, as defined in the Apache-2.0 licence, shall be dual-licensed as above, without any additional terms or conditions.
Organisation: XMV Solutions GmbH
Email: oss@xmv.de
Website: https://xmv.de/en/oss/
GitHub: @XMV-Solutions-GmbH
List buckets (columns) within a Planner plan. Each bucket has id, name, plan_id, order_hint, etag. The order_hint follows Microsoft Graph's lexicographic ordering scheme (read-only — buckets ship pre-ordered as the user arranged them in Planner). Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| plan_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds useful behavioral detail: the order_hint follows Microsoft Graph's lexicographic scheme and buckets are pre-ordered. This goes beyond annotations without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: one for purpose, one for output fields and a behavioral note. No fluff, each sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an output schema exists, the description doesn't need to explain returns. It covers purpose, key behavior, and parameter context. Missing explicit usage guidance, but overall adequate for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must explain the parameter. It only mentions 'within a Planner plan', which weakly implies plan_id is a plan identifier. It fails to specify format, source, or how to obtain it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('buckets (columns) within a Planner plan'). It lists key output fields, distinguishing it from sibling tools that list plans or tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by requiring a plan_id, but does not explicitly state when to use this tool over alternatives (e.g., planner_tasks for tasks within buckets). No exclusionary guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one Microsoft Planner plan by id. Same shape as an entry returned by planner_plans. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| plan_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds 'Read-only' and shape reference, but no additional behavioral details like auth needs or rate limits. Adequate but minimal added value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, 20 words total, no redundancy. Front-loaded with the key action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple fetch tool with one parameter and an output schema present, the description is reasonably complete. It covers purpose, shape, and read-only nature. Could mention error handling or prerequisites but not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (plan_id) with 0% schema description coverage. The description mentions 'by id' but does not explain the format, source, or meaning of the plan_id parameter, leaving the agent with insufficient guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetch one Microsoft Planner plan by id' with a specific verb and resource, and distinguishes itself from the sibling tool 'planner_plans' by referencing its shape.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context ('by id', 'Read-only') and implies usage for fetching a single plan, but does not explicitly state when NOT to use it or list alternative tools beyond planner_plans.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Microsoft Planner plans the signed-in user can see. Without group_id, enumerates the user's M365 groups via /me/memberOf (requires Group.Read.All admin-consent — already granted on the XMV-published OAuth app) and aggregates plans across them. With group_id, lists plans within that single group. Each plan has id, title, owner_group_id, created_date_time, etag. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| group_id | No | ||
| limit | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses internal behavior (enumerates groups via /me/memberOf, aggregates plans), permission requirements, and read-only nature. Annotations already indicate readOnlyHint and idempotentHint, and description aligns and adds context (fields returned, OAuth app specifics). No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, each serving a purpose: main action, two behavioral cases, output fields. Efficient but could be slightly tighter (e.g., combine last two sentences).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers main behaviors, output fields, and permission context. Has output schema (not shown). Missing details like pagination behavior (limit implies pagination), error handling, or rate limits, but adequate for a list tool with annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
group_id parameter is well-explained (function with vs without). However, limit parameter (default 50) is not described at all, leaving its purpose vague. Schema coverage is 0%, so description partially compensates but not fully.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'List' on resource 'Microsoft Planner plans'. Differentiates behavior with and without group_id. Distinct from sibling tools like planner_plan_get (single plan).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly describes when to use each parameter (without group_id aggregates across groups, with group_id lists within one). Mentions required permission (Group.Read.All) and that it's pre-granted. However, does not explicitly exclude alternatives or state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one Planner task by id. Returns the unified task envelope (same shape as items in planner_tasks). Pass include_details=True to additionally fetch the task's description, checklist, references, and preview_type (one extra Graph round-trip to /planner/tasks/{id}/details). Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | ||
| include_details | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and idempotentHint. The description adds behavioral context by explaining the extra round-trip for include_details, which goes beyond annotations. However, it does not discuss permissions or rate limits, which is acceptable for a simple read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core action, and efficiently conveys key details without redundancy. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 parameters, output schema documented as same shape as planner_tasks), the description covers the return shape, the optional details behavior, and the read-only nature. No gaps are present for a get-by-id tool with annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains both parameters: task_id is implied by 'by id', and include_details is explicitly described with the additional data it fetches (description, checklist, references, preview_type) and the extra round-trip. This adds significant meaning beyond the schema, which has 0% description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetch one Planner task by id', specifying the verb and resource. It distinguishes from sibling tools like planner_tasks which lists tasks, and todo_task_get for Todo tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a task ID, but does not explicitly compare with alternatives like planner_tasks or tasks_search. It mentions include_details option but lacks guidance on when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List tasks within a Planner plan. Returns each task in the unified envelope: id, title, status (completed/not_completed — derived from percentComplete >= 100), due_date, assignees (list of M365 user-ids assigned to the task), web_url (deep-link to tasks.office.com built from the access token's tid claim), source ('planner'), etag, plan_id, bucket_id, priority, percent_complete, applied_categories, created_date_time, last_modified_date_time. Optionally narrow by bucket_id and status_filter ('all'/'completed'/'not_completed').
| Name | Required | Description | Default |
|---|---|---|---|
| plan_id | Yes | ||
| bucket_id | No | ||
| status_filter | No | all | |
| limit | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint and idempotentHint. The description adds value by detailing derived fields (status from percentComplete, web_url from tid claim) and listing all returned fields. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph with a clear front-loaded purpose. Although it lists many fields, it remains readable and not overly verbose. Could be slightly more structured, but it is concise enough.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With output schema existing, the description's enumeration of return fields is somewhat redundant but adds clarity. However, it misses crucial context like pagination behavior (limit without continuation token) and how to obtain the required plan_id. This leaves the agent potentially uncertain about full usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains bucket_id and status_filter with valid values and defaults, but does not describe plan_id (how to obtain) or limit (pagination behavior). This leaves gaps for half of the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List tasks within a Planner plan,' which is a specific verb+resource combination. It distinguishes from sibling tools like 'planner_task_get' (single task) and 'tasks_assigned_to_me' (personal tasks) by focusing on plan-level tasks, but does not explicitly contrast them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains optional filtering by 'bucket_id' and 'status_filter', but does not provide guidance on when to use this tool versus alternatives like 'tasks_assigned_to_me' or 'planner_task_get'. No explicit when-not or context for choosing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Cross-source view: every Microsoft To Do task in the user's lists plus every Microsoft Planner task assigned to the user, merged into one list. Sorted by due_date ascending (None last). include_completed=False excludes completed tasks from both surfaces. Each entry is a unified task envelope tagged with source ('todo' or 'planner') and profile so the agent can route follow-up calls correctly. Optional profiles=[...] fans out across multiple signed-in tenants and merges; per-profile failures are best-effort skipped and listed in _skipped_profiles. Returns {'tasks': [...], '_skipped_profiles': [...]}. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| include_completed | No | ||
| limit | No | ||
| profiles | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral details beyond annotations: read-only, sorting by due_date, include_completed behavior, best-effort profile handling with _skipped_profiles. Annotations already indicate read-only and idempotence; description enriches with concrete behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but informative. Every sentence adds value, though it could be slightly more concise. It front-loads the core purpose and then details parameters and return format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (two sources, merging, profile handling) and the presence of an output schema (not shown but mentioned), the description covers return format, error handling (_skipped_profiles), and routing hints. It is complete for an AI agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description bears full burden. It explains include_completed (default false), limit (implicitly), and profiles (fan-out across tenants, best-effort skipping). Each parameter's effect is described.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is a cross-source view merging Microsoft To Do and Planner tasks, with sorting and source tags. This distinguishes it from sibling tools like todo_tasks and planner_tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool for cross-source listing and describes profile fan-out. While it does not explicitly state when not to use it or list alternatives, the context and sibling tool names imply differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Incremental diff of Microsoft Planner tasks since the last call. Polls Graph, compares against an on-disk cursor, and returns added, modified, removed envelopes plus cursor_advanced (bool). scope controls which tasks are polled — pass one of: {"kind": "plan", "plan_id": "..."} (all tasks in a plan), {"kind": "assigned_to_me"} (tasks assigned to the signed-in user), or {"kind": "registry"} (only tasks this MCP profile created — one GET per registry id). Each scope is tracked independently via a sha256 cursor key. First call → everything returned as added, cursor initialised. Subsequent calls return only tasks that appeared, changed (lastModifiedDateTime advanced), or disappeared since the previous poll. removed entries carry {"id": "...", "last_known_title": null} — the title is not available because the task is gone. Cursor file: ~/.cache/mcp-server-microsoft-tasks/<profile>/cursors.json, mode 0o600. Read-only on Graph; mutates only the local cursor file.
| Name | Required | Description | Default |
|---|---|---|---|
| scope | Yes | ||
| max_results | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes far beyond annotations by detailing the polling mechanism, cursor state management, file system interactions, and scope tracking. It explains edge cases like removed entries with null titles and the cursor file location and permissions. Annotations provide readOnlyHint and non-idempotent, which are consistent and supplemented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense paragraph that front-loads the purpose and then systematically explains behavior, scope options, edge cases, and file details. Every sentence adds value, though a bullet-point structure could improve readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (stateful incremental diff, multiple scope types, file system writes, output envelope format), the description is remarkably complete. It covers all key aspects including removed entry structure, cursor initialization, and security (file mode 0o600). The output schema exists but is not shown; however, the description explains the return format adequately.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The scope parameter is extensively described with three possible kinds (plan, assigned_to_me, registry) and their semantics, including cursor key derivation. The max_results parameter is not mentioned in the description, but it has a default of 200 and is a simple integer. With 0% schema description coverage, the description compensates well for scope but not fully for max_results.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it provides an incremental diff of Microsoft Planner tasks since the last call, detailing the output format and scope mechanisms. It clearly distinguishes itself from sibling tools like planner_tasks or tasks_search by focusing on change tracking rather than full listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use this tool (for polling incremental changes) and describes first-call vs subsequent-call behavior. It does not explicitly state when not to use it or mention alternatives, but the context of incremental sync is well-established.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Drive the OAuth Device Code flow as an MCP tool. Returns immediately, non-blocking. Surfaces user_code + verification_url so the agent can show them; polls Microsoft Identity in the background until the user completes sign-in OR the device code expires (~15 min cap). The agent then polls tasks_login_status until it flips to signed_in (or to a terminal expired / failed). REQUIRED parameter account_type: pass 'personal' for outlook.com / hotmail.com / live.com / msn.com (Microsoft To Do works; Planner does NOT — requires a work/school M365 group), or 'work_or_school' for any Microsoft 365 tenant account incl. B2B guests (both To Do and Planner work). The choice determines which Microsoft Device Code landing page the user is sent to (https://www.microsoft.com/link vs https://login.microsoft.com/device) — there is no auto-detection before sign-in. If you don't know, ASK THE USER first. Calling without account_type returns a structured error explicitly instructing you to elicit the choice. Idempotent: a non-expired pending session for the profile is returned as-is unless force=True. force=True cancels the in-flight session and starts a fresh flow. Returns the session's public view: session_id, user_code, verification_url, verification_url_complete, expires_at, time_remaining_s, status, signed_in_user_upn, error. AGENT_INSTRUCTIONS: Present the verification code to the user inside a fenced code block (so it can be copied with one click) and present the verification URL as a plain markdown link on its own line. Do not paraphrase, do not embed the code inside prose, do not wrap the URL in bold. Example:
Code:
```
ABCD-1234
```
Sign-in URL: https://www.microsoft.com/linkRationale: in a chat UI, a code inside a fenced block gets a one-click copy button; a bare URL becomes clickable; bold-wrapped links and inline codes do not.
| Name | Required | Description | Default |
|---|---|---|---|
| account_type | No | ||
| force | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description discloses non-blocking, polling in background, expiry ~15 min, idempotent, and error behavior. Annotations include `idempotentHint=true` and `readOnlyHint=false`, which match. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is comprehensive but somewhat lengthy. However, it is front-loaded with a clear summary and every sentence adds value, including agent instructions and example. Could be slightly more concise but still effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of OAuth flow and the presence of an output schema, the description covers initiation, polling, parameters, errors, agent actions, and example. It references sibling `tasks_login_status` for follow-up.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has no descriptions (0% coverage). Description fully explains `account_type` with values 'personal' and 'work_or_school', including implications for URL and functionality. It also explains `force` flag and its effect.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'Drive the OAuth Device Code flow as an MCP tool.' It further explains it initiates login and returns immediately. It differentiates from sibling `tasks_login_status` which polls for completion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use (for login), specifies required parameter `account_type` with guidance to ask user if unsure, describes idempotent behavior and `force` flag, and provides agent instructions for presenting the code and URL.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the current Microsoft 365 sign-in status for this profile. Three states: signed_in (a usable token exists, regardless of how it got there — CLI login, tasks_login_begin tool, even days ago), pending (a Device Code flow is in flight from a recent tasks_login_begin call; the response carries user_code + verification_url so the agent can re-display the prompt), or none (no token, no flow — the agent should call tasks_login_begin). Read-only: actively probes the token store + does at most one /me round-trip on a fresh signed_in to learn the UPN. AGENT_INSTRUCTIONS: When status='pending', present the verification code to the user inside a fenced code block (so it can be copied with one click) and present the verification URL as a plain markdown link on its own line. Do not paraphrase, do not embed the code inside prose, do not wrap the URL in bold. Same format as tasks_login_begin.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, and the description adds further detail: it actively probes the token store and performs at most one /me round-trip to learn the UPN. The pending state behavior and payload fields are fully disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is comprehensive but slightly verbose due to detailed AGENT_INSTRUCTIONS. However, every sentence adds value, and the purpose is clearly stated in the first sentence. It is well-structured and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the availability of an output schema (context signal), the description need not explain return values. It fully covers the tool's behavior, states, and agent instructions, making it complete for an AI agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is 100%. According to the rubric, 0 parameters yields a baseline of 4. The description does not need to add parameter information, as there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states exactly what the tool does: return the current sign-in status for Microsoft 365. It enumerates the three possible states and their meanings, and clearly distinguishes from sibling tools like tasks_login_begin by referencing it explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the tool and when to call alternatives: when status is 'none' the agent should call tasks_login_begin, and when 'pending' it should present the verification code and URL. It also clarifies that a signed_in token may exist from prior logins.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Case-insensitive substring search across the user's To Do tasks and Planner tasks. Matches against title and body_preview. source narrows to a single surface — 'all' (default), 'todo', or 'planner'. Returns up to limit matches in the unified envelope shape. Read-only. Note: implementation is client-side because neither surface exposes a server-side $search for tasks; performance is fine at typical task volumes (hundreds, not hundreds of thousands).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| source | No | all | |
| limit | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds valuable context: the search is client-side due to lack of server-side $search, and performance is fine for typical volumes. This goes beyond the annotations and helps set expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise, front-loading the core purpose and then adding parameter details and behavioral notes. Every sentence adds value, though it could be slightly shorter. It is well-structured and readable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, annotations covering safety and idempotency, and the description covering parameters and client-side behavior, the description is fully complete for an agent to understand and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description details the meaning of each parameter: 'query' is the substring, 'source' narrows to todo/planner/all, 'limit' caps results. This adds necessary semantics beyond the raw schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs a 'case-insensitive substring search' across tasks from To Do and Planner, matching against 'title' and 'body_preview'. It distinguishes itself from sibling tools like 'tasks_assigned_to_me' or 'planner_tasks' by being a search operation, and mentions parameters like 'source' and 'limit'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool (search across tasks) and notes it is read-only. It provides context on the client-side implementation and performance expectations. However, it does not explicitly mention when not to use it or list alternative tools, though sibling names are provided separately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a single Microsoft To Do list by id. Same shape as an entry returned by todo_lists. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| list_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds 'Read-only', confirming the annotations, and notes output shape similarity. No additional behavioral traits (e.g., rate limits, permission requirements) are disclosed, but given strong annotation coverage, the description adds marginal value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, contains zero fluff, and conveys essential purpose and relationship. Every word earns its place, and the structure is front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, read-only, with output schema and annotations), the description covers the core operation. However, the lack of parameter description and missing usage guidelines or error conditions leaves minor gaps, making it borderline complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter semantics. However, the description only says 'by id' without explaining the parameter name (`list_id`) or its format. The parameter name is self-descriptive, but the description adds no additional meaning beyond the schema field name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Fetch' and the resource 'a single Microsoft To Do list by id'. It explicitly distinguishes from sibling `todo_lists` by noting the same shape as an entry from that endpoint, making the tool's unique purpose unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (to fetch a single list by ID) but does not provide explicit guidance on when not to use it or mention alternatives beyond the implicit sibling relationship. The phrase 'Same shape as an entry returned by `todo_lists`' offers context but falls short of explicit usage rules.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the signed-in user's Microsoft To Do lists. Each list has id, display_name, is_owner, is_shared, well_known_list_name (e.g. 'defaultList' for the built-in Tasks list, 'flaggedEmails' for the Outlook flagged-mails list, or None for user-created lists), and etag. Read-only — does not modify anything. To list tasks within a list, pass the returned id to todo_tasks.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true. The description confirms 'Read-only — does not modify anything' and adds useful behavioral details about the data structure (e.g., well-known list names, etag). This additional context justifies a score above 3, though not a 5 because the annotations already cover the safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each earning its place: first states purpose, second details return fields, third clarifies read-only nature and usage alternative. No fluff; front-loaded with the action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, existing output schema, and sibling tool context, the description is fully complete. It covers purpose, behavior, fields, and when to use an alternative. Nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has one optional parameter 'limit' with default 50. The description does not mention this parameter, and schema description coverage is 0%. While the parameter is simple and self-explanatory, the description does not add any meaning beyond the schema, so a baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List the signed-in user's Microsoft To Do lists' with specific verb and resource. It distinguishes from sibling tools like todo_tasks by noting that to list tasks, pass the returned id to todo_tasks. It also enumerates returned fields, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states 'Read-only — does not modify anything' and provides a direct alternative: 'To list tasks within a list, pass the returned id to todo_tasks.' This tells the agent when to use this tool versus its sibling todo_tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one Microsoft To Do task by id within its list. Both list_id and task_id are required — Microsoft Graph has no global task-by-id endpoint for To Do. Returns the unified task envelope (same shape as items in todo_tasks). Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| list_id | Yes | ||
| task_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds value by explaining the return shape (unified task envelope, same as todo_tasks) and the reason for requiring both IDs, providing transparency beyond structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with three sentences, each serving a clear purpose: stating the action, explaining parameter necessity, and describing the output. No waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple get-by-id operation, the description covers all needed context: required parameters, return shape, and API limitation. With annotations and output schema, it is complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description compensates by explaining why both list_id and task_id are required due to API constraints. It adds meaning, though could be more detailed on format or examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches one Microsoft To Do task by ID within its list, distinguishing it from sibling tools like todo_tasks by specifying the need for both list_id and task_id. The mention of the API limitation adds clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains that both parameters are required and why, implying this tool is for fetching a single task. It could be more explicit about when not to use it (e.g., for listing tasks), but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List tasks in a Microsoft To Do list. Returns each task in the unified envelope: id, title, status (completed/not_completed), due_date, assignees (empty for To Do — per-user surface), web_url (None for To Do — no public deep-link), source (always 'todo'), etag (for write concurrency), list_id, body_preview, categories, importance, reminder_date, is_reminder_on, last_modified_date_time, created_date_time. status_filter defaults to 'all'; pass 'completed' or 'not_completed' to narrow.
| Name | Required | Description | Default |
|---|---|---|---|
| list_id | Yes | ||
| status_filter | No | all | |
| limit | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and idempotentHint=true. The description adds value by detailing the return fields, default behavior for status_filter, and limit, without contradicting annotations. It could mention pagination or rate limits but is sufficient for a read-only list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but well-structured, front-loading the action and then listing return fields concisely. It could be slightly shorter by omitting obvious field names, but it earns its space by providing context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, the description's detailed enumeration of return fields adds context. However, it lacks guidance on error handling (e.g., invalid list_id) and performance (e.g., limit implications), which are minor gaps for a list operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains status_filter defaults and limit, but the required parameter list_id is not described as input (only mentioned in return fields). This leaves a gap for agents without schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List tasks in a Microsoft To Do list' with a specific verb and resource, and it distinguishes itself from sibling tools like todo_task_get (single task) and todo_lists (list resources) by detailing the unified envelope and behavior specific to task listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by specifying defaults and filter options, but it does not explicitly state when to use this tool vs alternatives (e.g., for bulk listing vs. individual retrieval), nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.7.0planner_bucketsplanner_plan_getplanner_plansplanner_task_getplanner_taskstasks_assigned_to_metasks_changes_sincetasks_login_begintasks_login_statustasks_searchtodo_list_gettodo_liststodo_task_gettodo_tasksEach tool targets a distinct resource or action: Planner plans/buckets/tasks, To Do lists/tasks, cross-source views, search, incremental changes, and authentication. No overlap in purpose.
All tools follow a consistent verb_noun pattern with underscores (e.g., planner_plan_get, tasks_assigned_to_me, todo_lists), making them predictable for an agent.
14 tools is well-scoped for a task management server covering two surfaces (Planner and To Do) plus cross-source views and authentication. Each tool earns its place.
The tool set is almost entirely read-only; no create, update, or delete operations for tasks or lists are provided. This is a significant gap for a task management server, limiting agents to observation only.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Task management for people and AI agents, with scoped OAuth access to issues, projects, and docs.
AI-native task management: list, create, update and archive tasks with rich context for AI agents
Manage Superlist tasks and lists in plain language from any MCP-compatible AI agent.
Permissioned access to Outlook, OneDrive and Teams via the user's own Microsoft account
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/XMV-Solutions-GmbH/microsoft-tasks-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server