Skip to main content
Glama
deenesjakoruzh
themotionmachine

OmniFocus-MCP

by themotionmachine
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Local

OmniFocus MCP Server

npm version CI

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

OmniFocus MCP

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

At least one editable field is required — a call with only id/name/itemType is refused rather than reported as a successful no-op. Unrecognized argument keys (a note typo for newNote, say) are rejected by every tool with the key named in the error, instead of being silently dropped.

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.

A session that simply goes quiet is no longer disconnected: when the idle window passes with no traffic, the shim pings the client and keeps the session if it answers, so long-lived sessions (Claude Code and similar) keep their tools across long quiet stretches. Only a client that never answers is treated as gone.

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

Idle window after which the server pings the client and exits only if it gets no answer. 0 disables the check.

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
NameRequiredDescriptionDefault
deferDateNoThe defer date of the task in ISO format (YYYY-MM-DD or full ISO date)
dueDateNoThe due date of the task in ISO format (YYYY-MM-DD or full ISO date)
estimatedMinutesNoEstimated time to complete the task, in minutes
flaggedNoWhether the task is flagged or not
nameYesThe name of the task
noteNoAdditional notes for the task
projectNameNoThe name of the project to add the task to (will add to inbox if not specified)
tagsNoTags 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
NameRequiredDescriptionDefault
deferDateNoThe defer date of the project in ISO format (YYYY-MM-DD or full ISO date)
dueDateNoThe due date of the project in ISO format (YYYY-MM-DD or full ISO date)
estimatedMinutesNoEstimated time to complete the project, in minutes
flaggedNoWhether the project is flagged or not
folderNameNoThe name of the folder to add the project to (will add to root if not specified)
nameYesThe name of the project
noteNoAdditional notes for the project
sequentialNoWhether tasks in the project should be sequential (default: false)
tagsNoTags 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool adds a project but doesn't explain what happens upon success (e.g., returns a project ID), error conditions, permissions needed, or side effects. This is inadequate for a mutation tool with zero annotation coverage.

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 wasted words. It's appropriately sized and front-loaded, making it easy for an AI agent 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?

For a mutation tool ('add') with no annotations and no output schema, the description is insufficient. It doesn't cover behavioral aspects like return values, error handling, or system impacts, leaving significant gaps for an AI agent to understand how to use it effectively.

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 9 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to the rules, with high schema coverage, 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 a new project') and target resource ('to OmniFocus'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'add_omnifocus_task' or 'batch_add_items' that might also create items in OmniFocus, so it doesn't reach the highest score.

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 when to choose 'add_project' over 'add_omnifocus_task' (for tasks vs. projects) or 'batch_add_items' (for bulk operations), nor does it specify prerequisites or exclusions for project creation.

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
NameRequiredDescriptionDefault
itemsYesArray 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_itemsC

Remove multiple tasks or projects from OmniFocus in a single operation

ParametersJSON Schema
NameRequiredDescriptionDefault
itemsYesArray of items (tasks or projects) to remove

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 full burden. It states 'Remove' which implies a destructive mutation, but lacks details on permissions, reversibility, confirmation prompts, or error handling for partial failures. For a batch deletion tool with no annotation coverage, this is a significant gap in behavioral disclosure.

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 action and resource. Every word earns its place with no redundancy or fluff, making it highly concise and well-structured for quick comprehension.

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 tool's complexity (batch destructive operation) and lack of annotations and output schema, the description is insufficient. It doesn't cover critical aspects like return values, error conditions, or side effects. For a mutation tool with no structured safety hints, more completeness is needed to guide safe agent usage.

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 (id, itemType, name). The description adds no additional parameter semantics beyond implying batch processing. With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't need to heavily.

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 multiple tasks or projects') and resource ('from OmniFocus') with the scope of 'in a single operation'. It distinguishes from the sibling 'remove_item' by emphasizing batch capability, though it doesn't explicitly name that sibling. The purpose is specific but could be more precise about 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?

The description provides no guidance on when to use this tool versus alternatives like 'remove_item' or other deletion methods. It mentions batch removal but doesn't specify scenarios (e.g., efficiency for bulk cleanup) or prerequisites. Without explicit when/when-not instructions, usage context is implied at best.

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
NameRequiredDescriptionDefault
hideCompletedNoSet to false to show completed and dropped tasks (default: true)
hideRecurringDuplicatesNoSet 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Gets' implies a read operation, it doesn't specify what 'current state' includes (tasks, projects, tags, etc.), the format of the output, whether this is a heavy operation, or any performance considerations. For a database dump 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.

Conciseness4/5

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

The description is a single, efficient sentence that states the core purpose upfront. However, given the complexity of a database dump operation and the many sibling alternatives, this extreme conciseness comes at the cost of helpful context that would aid tool selection.

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 database dump tool with no annotations, no output schema, and 15 sibling retrieval tools, the description is incomplete. It doesn't explain what data is included in the dump, the output format, how this differs from more targeted retrieval tools, or any performance implications. The agent lacks sufficient context to use this tool effectively.

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 fully documents both parameters (hideCompleted and hideRecurringDuplicates). The description adds no parameter information beyond what's in the schema, meeting the baseline 3 for high schema coverage.

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 ('Gets') and resource ('current state of your OmniFocus database'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from its many sibling tools that also retrieve task/project data (like get_flagged_tasks, get_inbox_tasks, etc.), which would require a 5.

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. With 15 sibling tools that retrieve various subsets of OmniFocus data, the agent receives no help in choosing between a full database dump and more targeted retrieval tools like get_flagged_tasks or filter_tasks.

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
NameRequiredDescriptionDefault
addTagsNoTags to add to the task
idNoThe ID of the task or project to edit
itemTypeYesType of item to edit ('task' or 'project')
nameNoThe name of the task or project to edit (as fallback if ID not provided)
newDeferDateNoNew defer date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear
newDueDateNoNew due date in ISO format (YYYY-MM-DD or full ISO date); set to empty string to clear
newEstimatedMinutesNoNew estimated minutes
newFlaggedNoSet flagged status (set to false for no flag, true for flag)
newFolderNameNoNew folder to move the project to
newNameNoNew name for the item
newNoteNoNew note for the item
newProjectStatusNoNew status for projects
newSequentialNoWhether the project should be sequential
newStatusNoNew status for tasks (incomplete, completed, dropped)
removeTagsNoTags to remove from the task
replaceTagsNoTags 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 for behavioral disclosure but only states the basic purpose. It doesn't mention that this is a mutation operation (implied by 'Edit'), what permissions are needed, whether changes are reversible, error conditions, or what happens when multiple parameters are provided simultaneously (e.g., addTags vs replaceTags).

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 unnecessary words. It's appropriately sized for a tool with comprehensive schema documentation, though it could benefit from additional context about usage and behavior.

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 complex mutation tool with 16 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns, error handling, or behavioral nuances. The agent must rely entirely on the input schema for understanding, which lacks context about how the edit operation actually works in practice.

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 all parameters are documented in the schema itself. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in 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 ('Edit') and target ('a task or project in OmniFocus'), providing specific verb+resource. However, it doesn't distinguish this from sibling tools like 'remove_item' or 'add_omnifocus_task' beyond the basic edit vs add/remove distinction, missing opportunities to clarify scope boundaries.

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 (like needing an existing item ID), when to choose edit over remove+add, or how it differs from batch operations available in sibling tools like 'batch_add_items' or 'batch_remove_items'.

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
NameRequiredDescriptionDefault
idNoThe ID of the task or project to remove
itemTypeYesType of item to remove ('task' or 'project')
nameNoThe 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 but only states the action without behavioral details. It doesn't disclose if removal is permanent, requires specific permissions, has side effects, or what happens to dependent items, which is critical 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 front-loads the core action and resource without any wasted words. It's appropriately sized for a simple tool, 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?

For a destructive tool with no annotations and no output schema, the description is incomplete. It lacks critical context such as the permanence of removal, error handling, or return values, leaving significant gaps for safe agent invocation.

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 parameters. The description adds no extra meaning beyond implying removal targets tasks or projects, matching the schema. Baseline 3 is appropriate as the schema handles parameter semantics adequately.

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 the resource ('a task or project from OmniFocus'), making the purpose immediately understandable. It doesn't distinguish from sibling tools like 'batch_remove_items' or 'edit_item', which prevents a perfect score.

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 'batch_remove_items' for multiple items or 'edit_item' for modifications. It also doesn't mention prerequisites or context for removal, leaving usage unclear.

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.

  1. 7 tool updatesv1.0.0
    • First observedadd_omnifocus_task
    • First observedadd_project
    • First observedbatch_add_items
    • First observedbatch_remove_items
    • First observeddump_database
    • First observededit_item
    • First observedremove_item
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.5/5.0

Scored across 7 tools

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

ActivityActive
ResponsivenessWithin a week

Resources

Related MCP Connectors

Related MCP Servers

  • MCP OmniFocus

    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.
    12
    MIT

  • OmniFocus MCP Server

    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.
    31
    11 npm
    MIT

Appeared in Searches