What can you do with this server?

The OmniFocus-MCP server enables AI assistants like Claude to interact with your OmniFocus task management system through natural language. You can: * View tasks and projects: Retrieve the current state of your OmniFocus database * Add tasks and projects: Create new items with details like names, notes, due dates, tags, flags, estimated time, etc. * Edit existing items: Modify properties including names, notes, statuses, dates, tags, and more * Remove tasks and projects: Delete specific items by ID or name * Perform batch operations: Add or remove multiple tasks/projects simultaneously * Customize properties: Set defer dates, flags, estimated completion times, folder locations, and sequential project settings * Manage tags: Add, remove, or replace tags on tasks and projects * Process complex inputs: Transform conversations, transcripts or PDFs into structured OmniFocus items

Which integrations are available for this server?

Required operating system for running the MCP server, as OmniFocus is a macOS-exclusive application.

How do I use OmniFocus-MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@OmniFocus-MCP show me all flagged tasks due this week" 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.

de en es ja ko ru zh

OmniFocus-MCP

by themotionmachine

Overview Schema Related Servers Score Discussions

TypeScript

Local

OmniFocus MCP Server

npm version

A Model Context Protocol (MCP) server that connects OmniFocus to Claude and other MCP-compatible AI assistants.

Overview

This server bridges AI assistants and your OmniFocus database. Through natural conversation, an assistant can query, create, edit, and remove tasks and projects — including bulk operations. Some things you can do with it:

Translate a syllabus PDF into a fully specified project with tasks, tags, defer dates, and due dates
Turn a meeting transcript into a list of actions
Audit and reorganize your tags, projects, and folders conversationally
Create visualizations of your tasks, projects, and tags
Process dozens of items in a single batch operation

Related MCP server: MCP OmniFocus

Quick Start

Prerequisites

macOS with OmniFocus installed
Node.js 20 or later (for npx)

The first time the server talks to OmniFocus, macOS will ask you to allow automation access. Grant it once and you're set.

Claude Desktop

Add the server to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "omnifocus": {
      "command": "npx",
      "args": ["-y", "omnifocus-mcp"]
    }
  }
}

Then restart Claude Desktop.

Claude Code

claude mcp add omnifocus -- npx -y omnifocus-mcp

Other MCP clients work the same way: launch npx -y omnifocus-mcp over stdio.

Example Conversations

Targeted queries:

"Show me all my flagged tasks due this week"
"What are my next actions in the Work folder?"
"Count how many tasks are in each project"

Reorganizing:

"I want every task to have an energy level tag. Show me a list of all the tasks that don't have one and your suggestions for what tag to add. I'll make any changes I think are appropriate. Then make the changes in OmniFocus."

Capturing from anywhere:

"Ok, thanks for the detailed explanation of why the rule of law is important. Add a recurring task to my activism project that reminds me to call my representative weekly. Include a summary of this conversation in the notes field."

Working with perspectives:

"What perspectives do I have available?"
"Show me what's in my Inbox perspective"

Processing transcripts or PDFs:

"I'm pasting in the transcript from today's meeting. Please analyze it and create tasks in OmniFocus for any action items assigned to me. Put them in my 'Product Development' project."

Tools

The server provides 12 tools. Optional parameters are marked.

`query_omnifocus`

Query tasks, projects, or folders with targeted filters — much faster and lighter than dumping the whole database. See QUERY_TOOL_REFERENCE.md for the full reference and QUERY_TOOL_EXAMPLES.md for worked examples.

Parameter	Description
`entity`	What to query: `tasks`, `projects`, or `folders`
`filters` (optional)	Combine with AND logic; array filters (`tags`, `status`) use OR within the array
`fields` (optional)	Only return the listed fields — keeps responses small
`limit`, `sortBy`, `sortOrder` (optional)	Shape the result list
`includeCompleted` (optional)	Include completed/dropped items (default: false)
`summary` (optional)	Return only the match count

Available filters:

Containers: projectName (case-insensitive partial match; "inbox" targets the inbox), projectId, folderId (includes subfolders), folderName (case-insensitive partial match, includes subfolders)
Names: taskName (case-insensitive partial match)
Tags: tags (exact match, case-sensitive)
Status: status — tasks: Next, Available, Blocked, DueSoon, Overdue, Completed, Dropped; projects: Active, OnHold, Done, Dropped
Dates, forward-looking: dueWithin, deferredUntil, plannedWithin (ranges), dueOn, deferOn, plannedOn (exact day). Accept a number of days, "today", "tomorrow", "this week", "next week", or an ISO date
Dates, backward-looking: addedWithin, addedOn, completedWithin, completedOn, droppedWithin, droppedOn (completed/dropped filters require includeCompleted: true)
Flags & misc: flagged, inbox, hasNote, isRepeating, reviewDue (projects only)

`dump_database`

Get the complete state of your database. Use for comprehensive analysis; prefer query_omnifocus for anything targeted.

hideCompleted (optional): hide completed/dropped tasks (default: true)
hideRecurringDuplicates (optional): hide duplicate instances of recurring tasks (default: true)

`add_omnifocus_task`

Create a new task.

name
projectName (optional): project to add the task to (defaults to inbox)
parentTaskId / parentTaskName (optional): nest under an existing task
note, dueDate, deferDate, plannedDate, flagged, estimatedMinutes, tags (all optional)
repeat (optional): make it recurring — see Repeating items

`add_project`

Create a new project.

name
folderName (optional): folder to place the project in
sequential (optional): whether tasks must be completed in order
note, dueDate, deferDate, flagged, estimatedMinutes, tags, repeat (all optional)

`edit_item`

Edit an existing task or project. Also the way to move items — set newProjectName to move a task into a project, or to ""/"inbox" to send it to the inbox.

id or name: which item to edit (id takes precedence)
itemType: task or project
Common: newName, newNote, newDueDate, newDeferDate, newFlagged, newEstimatedMinutes (dates in ISO format; empty string clears)
Tasks: newStatus (incomplete, completed, dropped, skipped — skipped only for repeating tasks), addTags, removeTags, replaceTags, newProjectName, newPlannedDate
Projects: newProjectStatus (active, completed, dropped, onHold), newFolderName, newSequential, markReviewed (sets the next review date based on the project's review interval)
Repetition: newRepeat sets a new rule (same shape as repeat on create); newRepeat: null clears it

`remove_item`

Remove a task or project.

id or name: which item to remove
itemType: task or project

`batch_add_items`

Create multiple tasks and projects in one operation. Each item accepts the same fields as add_omnifocus_task / add_project, plus type (task or project) and optional hierarchy helpers:

tempId: a temporary ID other items in the same batch can reference
parentTempId: nest this item under another batch item's tempId

{
  "items": [
    { "type": "project", "name": "My Project", "tempId": "proj1" },
    { "type": "task", "name": "First task", "parentTempId": "proj1" },
    { "type": "task", "name": "Parent task", "parentTempId": "proj1", "tempId": "t1" },
    { "type": "task", "name": "Subtask", "parentTempId": "t1" }
  ]
}

`batch_remove_items`

Remove multiple tasks or projects in one operation. Each item takes id or name, plus itemType.

`list_perspectives`

List available perspectives, both built-in and custom (custom perspectives are an OmniFocus Pro feature).

includeBuiltIn, includeCustom (optional, default: true)

`get_perspective_view`

Get the items visible in a named perspective.

perspectiveName: e.g. Inbox, Flagged, or a custom perspective name
limit (optional, default: 100), includeMetadata (optional), fields (optional)

`list_tags`

List all tags with their hierarchy, active status, and task counts.

includeDropped (optional, default: false)

`create_tag`

Create a tag, optionally nested under an existing parent.

name
parentTagName / parentTagID (optional; ID takes precedence)

Repeating items

add_omnifocus_task, add_project, and each item in batch_add_items accept a repeat object; edit_item accepts newRepeat. You describe the schedule and the server compiles the ICS recurrence rule, so you never hand-write an RRULE.

Field	Description
`method`	`start-after-completion` (counts from when it's actually done), `fixed` (counts from the calendar regardless), or `due-after-completion`
`unit`	`day`, `week`, `month`, or `year`
`steps` (optional)	Repeat every N units (default 1)
`weekdays` (optional)	Specific days, e.g. `["MO","WE","FR"]`. Requires `unit: "week"`

{ "name": "Weekly review", "repeat": { "method": "start-after-completion", "unit": "week" } }
{ "name": "Strength work", "repeat": { "method": "fixed", "unit": "week", "weekdays": ["TU","TH"] } }

Pick method deliberately — it's the field most often set wrong by hand. With fixed, occurrences appear on schedule whether or not the last one was done, so a missed week leaves a backlog to clear. With start-after-completion, the next occurrence is scheduled from when you actually complete it, so the habit simply resumes.

Read a rule back with query_omnifocus using the repetitionRule (ICS string) and repetitionMethod fields, or filter with isRepeating.

Not currently supported: positional monthly rules ("third Tuesday"), specific month days, and end conditions (COUNT/UNTIL). Set those in OmniFocus directly.

Resources

Resources let MCP clients attach OmniFocus data to a conversation as context, without tool calls. In Claude Code, type @ to browse them; Claude Desktop and other resource-aware clients can attach them directly. All resources return JSON.

URI	Description
`omnifocus://inbox`	Current inbox items
`omnifocus://today`	Today's agenda — due today, planned for today, and overdue
`omnifocus://flagged`	All flagged items
`omnifocus://stats`	Database statistics (task counts, overdue, flagged, etc.)
`omnifocus://project/{name}`	Tasks in a specific project
`omnifocus://perspective/{name}`	Items visible in a named perspective

The two template resources support listing all available values and autocompleting the {name} parameter.

Server Instructions & Logging

Instructions: during the MCP handshake the server sends usage guidance to the client — tool-selection advice (prefer query_omnifocus over dump_database), filter tips, and the resource catalog. No configuration needed.

Logging: the server emits structured logs via the MCP logging protocol. Clients can adjust verbosity with logging/setLevel (debug, info, warning, error, ...). Script execution timing and errors are logged automatically.

How It Works

The server communicates with OmniFocus through osascript, using JXA (JavaScript for Automation) and OmniFocus's embedded Omni Automation (OmniJS) where appropriate. It's built on the official MCP TypeScript SDK and talks to clients over stdio.

Shared daemon

Launching omnifocus-mcp starts a small shim that connects to a shared background daemon, starting one if it isn't already running. Every client on the machine gets its own independent MCP session, but they all run inside that single process.

This matters when several agents use OmniFocus at once. OmniFocus is a single-threaded application driven over AppleEvents, and the server caps how many osascript calls it will run concurrently. When each client ran its own server, that cap was per-process — ten clients meant ten independent budgets aimed at one app, causing AppleEvent timeouts. Sharing one process makes the cap global.

The daemon listens on a Unix domain socket in a 0700 directory (~/.omnifocus-mcp/daemon-<version>.sock by default), so access is enforced by the filesystem — no network port and no token. It exits on its own once no client has been connected for the idle window, and logs to daemon.log beside the socket.

The socket name carries the package version so that upgrading can never leave you talking to the previous version's daemon. Right after an upgrade you may briefly see two daemons: the old one keeps serving the clients already attached to it and exits once the last of them disconnects. Clients still attached to the old daemon are told about it in-band — while a newer daemon is serving, every tool result carries a one-line upgrade notice, so nobody has to remember to reconnect.

If the daemon dies while clients are attached — a crash, or a manual kill during troubleshooting — each shim now reconnects, replays its client's initialize handshake to the new daemon, and fails any in-flight requests with a retryable error rather than leaving the client waiting. Previously the shim exited, which cost clients their tools for the rest of the session.

Nothing about client configuration changes. If the daemon can't be started — an unusual sandbox, a read-only home directory — the shim falls back to running a standalone server in-process, exactly as earlier versions did.

Repeating items and occurrence safety

OmniFocus keeps each completed occurrence of a repeating item as its own row, carrying the same name and the same repetition rule as the live one. A query with includeCompleted: true therefore returns rows that look like duplicates but are history.

query_omnifocus marks them — ⟲ past occurrence — not a duplicate — via an isPastOccurrence field included in the default projection. edit_item and remove_item refuse to mutate one by default, because doing so cascades through the live repeat chain; pass allowPastOccurrence: true if you genuinely mean the historical row.

Note that the check is on repeating item plus terminal status, not on the shape of the id. A repeating project's live identifier is itself dotted (abc.116 can be the active project while abc.116.43 is history), so refusing dotted ids would make repeating projects uneditable.

Environment variables

Variable	Default	Purpose
`OMNIFOCUS_MCP_NO_DAEMON`	unset	Set to `1` to skip the daemon entirely and run a dedicated server per client (the pre-daemon behavior). First thing to try if you suspect the daemon.
`OMNIFOCUS_MCP_SOCKET`	`~/.omnifocus-mcp/daemon-<version>.sock`	Override the socket path, e.g. to run an isolated instance.
`OMNIFOCUS_MCP_IDLE_TIMEOUT_MINUTES`	`30`	Exit after this long with no client traffic. `0` disables the timeout.
`OMNIFOCUS_MCP_MAX_CONCURRENT_OSASCRIPT`	`4`	Maximum concurrent `osascript` calls. Lower it if you still see AppleEvent timeouts.

Roadmap

MCP prompt support
Manipulating notifications for projects and tasks
See the GitHub issues for feature requests and known issues

Contributing

Contributions are welcome! Please feel free to submit a pull request. CI runs type checking, unit tests, and a build on every PR.

npm install
npm test            # unit tests
npm run build       # compile to dist/
npm run test:integration  # requires OmniFocus; creates and removes TEST:-prefixed items

License

MIT

Available Tools

7 tools

add_omnifocus_taskC

Add a new task to OmniFocus

ParametersJSON Schema

Name	Required	Description
`deferDate`	No	The defer date of the task in ISO format (YYYY-MM-DD or full ISO date)
`dueDate`	No	The due date of the task in ISO format (YYYY-MM-DD or full ISO date)
`estimatedMinutes`	No	Estimated time to complete the task, in minutes
`flagged`	No	Whether the task is flagged or not
`name`	Yes	The name of the task
`note`	No	Additional notes for the task
`projectName`	No	The name of the project to add the task to (will add to inbox if not specified)
`tags`	No	Tags to assign to the task

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Add a new task' implies a write operation, it doesn't specify whether this requires authentication, what happens on success/failure, if there are rate limits, or how errors are handled. For a mutation tool with zero annotation coverage, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that states the core purpose without any wasted words. It's appropriately sized and front-loaded, making it easy for an agent to quickly understand what the tool does.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with 8 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what happens after task creation, what the return value might be, or provide any behavioral context. The description should do more to compensate for the lack of structured metadata.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 8 parameters. The description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Add') and resource ('new task to OmniFocus'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'add_project' or 'edit_item', which would require mentioning this is specifically for tasks rather than projects or editing existing items.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like 'add_project', 'edit_item', or 'batch_add_items'. The description doesn't mention prerequisites, context, or any exclusions that would help an agent choose between these sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

add_projectC

Add a new project to OmniFocus

ParametersJSON Schema

Name	Required	Description
`deferDate`	No	The defer date of the project in ISO format (YYYY-MM-DD or full ISO date)
`dueDate`	No	The due date of the project in ISO format (YYYY-MM-DD or full ISO date)
`estimatedMinutes`	No	Estimated time to complete the project, in minutes
`flagged`	No	Whether the project is flagged or not
`folderName`	No	The name of the folder to add the project to (will add to root if not specified)
`name`	Yes	The name of the project
`note`	No	Additional notes for the project
`sequential`	No	Whether tasks in the project should be sequential (default: false)
`tags`	No	Tags to assign to the project

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure but only states the basic action. It doesn't mention what happens on success/failure, whether the operation is idempotent, permission requirements, rate limits, or any side effects. For a creation tool with zero annotation coverage, this leaves critical behavioral aspects undocumented.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no wasted words. It's appropriately sized for a tool with good schema documentation and gets straight to the point without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a creation tool with 9 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what constitutes a valid project, how the system responds, error conditions, or relationships with sibling tools. The agent would need to infer too much from the minimal description alone.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% description coverage, so all parameters are documented in the structured schema. The description adds no additional parameter information beyond what's already in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Add a new project') and the target resource ('to OmniFocus'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'add_omnifocus_task', which creates ambiguity about when to use one versus the other for project-related operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'add_omnifocus_task' or 'batch_add_items'. There's no mention of prerequisites, constraints, or typical use cases, leaving the agent to guess based on tool names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

batch_add_itemsB

Add multiple tasks or projects to OmniFocus in a single operation

ParametersJSON Schema

Name	Required	Description	Default
`items`	Yes	Array of items (tasks or projects) to add

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but only states it's a batch addition operation. It doesn't disclose behavioral traits such as whether it's idempotent, requires specific permissions, handles errors, or returns any output. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads key information ('Add multiple tasks or projects') without unnecessary words. It earns its place by clarifying the batch nature and target system, making it appropriately sized and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is incomplete for a mutation tool. It lacks details on behavioral context, error handling, or return values, which are crucial for an agent to use it correctly. The high schema coverage doesn't compensate for these gaps in operational transparency.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the schema fully documents the 'items' parameter and its nested properties. The description adds no parameter semantics beyond implying batch processing, which is already covered by the tool name and schema. Baseline 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Add multiple tasks or projects') and target ('to OmniFocus in a single operation'), making the purpose evident. It distinguishes from single-item tools like 'add_omnifocus_task' and 'add_project' by emphasizing batch capability, though it doesn't explicitly name these siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for adding multiple items at once, suggesting it's an alternative to single-item tools. However, it doesn't explicitly state when to use this over siblings like 'add_omnifocus_task' or 'add_project', nor does it mention prerequisites or exclusions, leaving guidance incomplete.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

batch_remove_itemsB

Remove multiple tasks or projects from OmniFocus in a single operation

ParametersJSON Schema

Name	Required	Description	Default
`items`	Yes	Array of items (tasks or projects) to remove

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but only states it's a removal operation. It doesn't disclose critical behavioral traits like whether removal is permanent/reversible, permissions required, rate limits, error behavior for partial failures, or what happens to dependent items. The description is minimal and lacks necessary context for a destructive operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy to understand immediately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive batch operation with no annotations and no output schema, the description is inadequate. It doesn't explain what 'remove' means (delete, archive, etc.), return values, error handling, or important constraints. Given the complexity and lack of structured data, more completeness is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents the 'items' parameter and its nested properties. The description adds no additional parameter semantics beyond implying batch removal, which is already clear from the name and schema. Baseline 3 is appropriate when schema does all the work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('remove') and resource ('multiple tasks or projects from OmniFocus'), specifying it's a batch operation. It distinguishes from the sibling 'remove_item' by emphasizing 'multiple... in a single operation', but doesn't explicitly name that sibling for full differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when removing multiple items at once versus single items, but doesn't explicitly state when to use this tool versus 'remove_item' or other alternatives. No guidance on prerequisites, error handling, or specific scenarios is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dump_databaseC

Gets the current state of your OmniFocus database

ParametersJSON Schema

Name	Required	Description	Default
`hideCompleted`	No	Set to false to show completed and dropped tasks (default: true)
`hideRecurringDuplicates`	No	Set to true to hide duplicate instances of recurring tasks (default: true)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'Gets the current state,' implying a read operation, but doesn't clarify critical aspects like whether this is a safe, non-destructive action, what permissions are required, or the format/scope of the returned data. For a tool with no annotations and no output schema, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It is appropriately sized and front-loaded, making it easy to parse quickly. Every part of the sentence earns its place by conveying essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (a database dump tool with no annotations and no output schema), the description is incomplete. It lacks details on behavioral traits (e.g., safety, permissions), usage context, and output format. While the schema covers parameters well, the overall context for the agent to invoke this tool correctly is insufficient, especially compared to sibling mutation tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds no parameter semantics beyond what the input schema provides. The schema has 100% description coverage, with clear explanations for both parameters ('hideCompleted' and 'hideRecurringDuplicates'), so the baseline is 3. The description doesn't compensate with additional context, such as explaining why these filters are useful or their impact on the output.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Gets') and resource ('current state of your OmniFocus database'), making it immediately understandable. However, it doesn't explicitly differentiate this tool from its siblings (like 'batch_add_items' or 'edit_item'), which would require a 5. The description avoids tautology by not just restating the name 'dump_database'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or exclusions. Given the sibling tools include various mutation operations (e.g., 'add_omnifocus_task', 'remove_item'), the agent must infer that this is a read-only tool for data retrieval, but this is not explicitly stated in the description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

edit_itemC

Edit a task or project in OmniFocus

ParametersJSON Schema

Name	Required	Description
`addTags`	No	Tags to add to the task
`id`	No	The ID of the task or project to edit
`itemType`	Yes	Type of item to edit ('task' or 'project')
`name`	No	The name of the task or project to edit (as fallback if ID not provided)
`newDeferDate`	No	New defer date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear
`newDueDate`	No	New due date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear
`newEstimatedMinutes`	No	New estimated minutes
`newFlagged`	No	Set flagged status (set to false for no flag, true for flag)
`newFolderName`	No	New folder to move the project to
`newName`	No	New name for the item
`newNote`	No	New note for the item
`newProjectStatus`	No	New status for projects
`newSequential`	No	Whether the project should be sequential
`newStatus`	No	New status for tasks (incomplete, completed, dropped)
`removeTags`	No	Tags to remove from the task
`replaceTags`	No	Tags to replace all existing tags with

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It states 'Edit' which implies mutation, but doesn't describe permissions needed, whether changes are reversible, error handling (e.g., if ID not found), or response format. For a complex 16-parameter mutation tool, this leaves significant gaps in understanding how it behaves.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every word earns its place: 'Edit' (action), 'a task or project' (targets), 'in OmniFocus' (context). No redundancy or fluff, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given high complexity (16 parameters, mutation operation), no annotations, and no output schema, the description is inadequate. It doesn't address behavioral aspects like side effects, error conditions, or what the tool returns. For a powerful edit tool with many parameters, more context is needed to use it effectively and safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 16 parameters with clear descriptions and enums. The description adds no parameter-specific information beyond what's in the schema, maintaining the baseline score of 3. It doesn't explain parameter interactions (e.g., how 'replaceTags' relates to 'addTags/removeTags') or provide usage examples.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Edit') and resource ('a task or project in OmniFocus'), providing specific action and target. It distinguishes from siblings like 'add_omnifocus_task' and 'remove_item' by focusing on modification rather than creation or deletion. However, it doesn't explicitly differentiate from all siblings (e.g., 'batch_add_items' might also involve modifications).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing item), exclusions (e.g., when batch operations might be better), or comparisons to siblings like 'batch_add_items' for multiple edits. Usage is implied but not explicitly stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

remove_itemC

Remove a task or project from OmniFocus

ParametersJSON Schema

Name	Required	Description
`id`	No	The ID of the task or project to remove
`itemType`	Yes	Type of item to remove ('task' or 'project')
`name`	No	The name of the task or project to remove (as fallback if ID not provided)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool removes items but doesn't clarify whether this is permanent deletion, requires specific permissions, affects related data, or provides confirmation feedback. For a destructive operation, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded with the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after removal, whether changes are reversible, what confirmation is provided, or how this differs from sibling tools. Given the complexity of a removal operation, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter semantics beyond what's in the schema - no explanation of the ID/name fallback relationship, no context about where to find IDs, or how itemType affects the operation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Remove') and target resource ('a task or project from OmniFocus'), providing specific verb+resource pairing. However, it doesn't distinguish this tool from its sibling 'batch_remove_items' which likely performs similar bulk operations, missing explicit differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided about when to use this tool versus alternatives like 'batch_remove_items' for multiple items or 'edit_item' for modifications instead of removal. The description lacks context about prerequisites, appropriate scenarios, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

7 tool updatesv1.0.0Aug 14, 2025
- First observedadd_omnifocus_task
- First observedadd_project
- First observedbatch_add_items
- First observedbatch_remove_items
- First observeddump_database
- First observededit_item
- First observedremove_item

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0

Disambiguation4/5

Most tools have distinct purposes, but there is some overlap between 'remove_item' and 'batch_remove_items', and 'edit_item' could be confused with individual add/edit operations. The descriptions help clarify, but the boundaries between single and batch operations are not perfectly clear.

Naming Consistency5/5

All tool names follow a consistent snake_case pattern with clear verb_noun structure (e.g., add_omnifocus_task, edit_item, dump_database). There are no deviations in naming conventions, making the set predictable and readable.

Tool Count5/5

With 7 tools, the count is well-scoped for managing tasks and projects in OmniFocus. Each tool serves a clear purpose, from basic CRUD operations to batch processing and database inspection, without feeling excessive or insufficient.

Completeness5/5

The tool set provides complete coverage for the OmniFocus domain, including create (add_task, add_project), read (dump_database), update (edit_item), and delete (remove_item, batch_remove_items) operations, plus batch additions. There are no obvious gaps that would hinder agent workflows.

Maintenance

ActivityMaintained

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
mcpOAuth
net.todoist
Official Todoist MCP server for AI assistants to manage tasks, projects, and workflows.
App Automation Workplace & Productivity Project Management
2
mcp-serverOAuth
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
ContexterOAuth
io.github.maaakso
Share one project context across ChatGPT, Claude, Telegram and any MCP client.
Knowledge & Memory Note Taking
1

Related MCP Servers

OmniFocus MCP Server
App Automation Developer Tools Project Management
mdoel
A
license
A
quality
D
maintenance
A Model Context Protocol server that integrates OmniFocus with Claude Desktop, providing AI-powered access to tasks and projects for enhanced task management and weekly reviews.
Updated a year ago (2025-06-20 01:58 UTC)
4
1,806
8
MIT
MCP OmniFocus
App Automation Project Management
someposer
A
license
B
quality
D
maintenance
A Model Context Protocol server that enables automation and management of OmniFocus tasks, projects, and tags using natural language and programmable interfaces from VS Code, command line, or any MCP-compatible client.
Updated a year ago (2025-06-22 22:18 UTC)
12
MIT
OmniFocus MCP
Project Management Workplace & Productivity
vitalyrodnenko
A
license
Not graded
quality
C
maintenance
MCP server that gives AI assistants full control over OmniFocus on macOS, including tasks, projects, tags, folders, perspectives, forecast, notifications, and review workflows.
Updated 5 months ago (2026-04-06 04:39 UTC)
42
MIT
OmniFocus MCP Server
Project Management Search
estrenuo
A
license
A
quality
B
maintenance
An MCP server that enables AI assistants to interact with OmniFocus on macOS via JXA, supporting task, project, folder, tag, perspective, and search operations.
Updated 22 days ago (2026-08-15 07:45 UTC)
31
25
MIT

Appeared in Searches

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/themotionmachine/OmniFocus-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server