Skip to main content
Glama

Server Details

Caddie connects AI agents to notes, tasks and calendar through an HTTP MCP server. Authenticate with a personal agent key from Settings > AI. Free while in beta.

If you are the author of this connector, you can claim ownership. Claimed connector authors can inspect health checks, view analytics, and manage their listing.
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

B3.1/5.0

Scored across 97 tools

Disambiguation3/5

Most tools target distinct resources, and descriptions do a lot to clarify boundaries. However, the set contains several overlapping clusters — task_status/task_wait/agent_tasks/task_reply, phone_ask/phone_result/notify_user, and search_notes/search_runs/search_transcripts — where an agent could easily select the wrong tool.

Naming Consistency3/5

The toolset is mostly snake_case and readable, but conventions are mixed: many action-first names (create_note, list_events, update_task) coexist with resource-first or noun names (agent_tasks, decisions_read, followups_list, linear_issues, phone_ask, task_status). With 97 tools, the naming is serviceable but not consistently predictable.

Tool Count1/5

97 tools is far beyond the reasonable range for a single MCP server and creates a serious selection burden. Even with detailed descriptions, the surface is too large to be practical as one toolset.

Completeness3/5

The server covers a very broad personal-productivity and agent-management domain, including notes, tasks, calendar, data tables, booking links, agents, habits, journal, memory, skills, Linear, Slack, and phone interactions. But there are notable lifecycle gaps: create_routine is referenced but absent, there is no create_agent tool, and data tables lack delete/update operations for the table itself or its columns.

Available Tools

97 tools
add_columnAInspect

Add a column to a data table: column is { name, type, options?, unique? } as in create_data_table. A select column's options are changed in Caddie: if a value you need isn't an option, ask the user rather than making a near-duplicate column.

Inputs: table (required), column (required), workspace.

add_dictation_wordsAInspect

Add names and terms to the user's dictation dictionary (Settings › Dictation), so their Mac spells them right when they dictate: people, companies, products, jargon. Up to 50 at a time, each under 40 characters; ones already there are skipped.

Inputs: words (required).

add_rowsAInspect

Add rows to a data table (up to 500 a call): each row is { "": value }. Values are checked against each column's type: numbers, dates as YYYY-MM-DD (or YYYY-MM-DDTHH:MM), true/false for checkboxes, select and status values must be one of the column's options (by name), multi-select takes a list. The call is all or nothing: if any row is wrong nothing is added and the error says which row and why. A value already in the table's unique column is rejected: use upsert_rows to update-or-add by that column.

Inputs: rows (required), table (required), workspace.

agent_replyBInspect

Whether an agent you asked (ask_agent) has answered, and its answer. Once you have it here, it isn't sent to this task again.

Inputs: request (required).

agent_tasksAInspect

For clients outside Caddie (T3 Code, Claude Code or Codex in a terminal) acting for the user: the user's agents' tasks with each one's state (working, queued, waiting_for_mac, waiting_for_ok, needs_user, failed, stopped, idle, done) and its last message. agent: one agent (name or id); include_done: done tasks too. A list of { agent, agent_id, tasks }, the newest 20 tasks each; when not all could be read, { agents, partial: true } with some of them. Caddie's own agents: use list_agents.

Inputs: agent, include_done.

append_to_noteAInspect

Add Markdown content (as create_note takes it) to the end of an existing note. If it's shared, its public page shows the addition at the same link. To change a note you've made or shared, edit it in place (update_note or append_to_note). Never make a new note and delete the old one: its share link is what the user has sent to people, and it would stop working.

Inputs: id (required), content (required), workspace.

archive_agentAInspect

Archive one of the user's agents, as Archive agent on the Agents page does: it moves under Done in the list, open tasks and all, and a message to it brings it back. Its routines keep running, as in the app (pause_routine stops one). unarchive: true puts it back in the list.

Inputs: agent (required), unarchive.

ask_agentAInspect

Ask another of the user's agents for something it's set up for (its tools, files, sign-ins or what it knows). It runs as a new task in that agent, on the Mac that runs it. from: your own "agent:task:key" from your instructions. With from, its answer comes back to this task as a new message by itself; without it (a client outside Caddie), it's a message to it marked as asked from outside Caddie via this client, and you get the answer with agent_reply (task_status follows the task, by the task_id it returns). wait_seconds (up to 50) waits here for a quick answer. Up to 4 asks an hour from one task. Don't ask it to do what you can do yourself.

Inputs: agent (required), message (required), from, wait_seconds.

create_collectionBInspect

Make an empty collection (folder) for notes. (create_note and move_note make one too when given a new name.)

Inputs: name (required), workspace.

create_data_tableAInspect

Make a data table. columns: [{ name, type, options?, unique? }]; type is text, number, select, multi, status, date, checkbox, email, url, person or note; options lists a select/multi/status column's choices (a status column without options gets To do, In progress, Done); unique: true on one column (say Email) makes upsert_rows match on it and keeps duplicates out. The first column is each row's title.

Inputs: name (required), columns (required), workspace.

create_eventAInspect

Create an event on the user's primary Google calendar. start is an ISO date-time with timezone offset (e.g. 2026-10-12T15:00:00+05:30); give end or minutes (default 30). attendees (up to 20 emails) are invited and Google emails them, so from an agent's own turn inside Caddie that's refused; meet: true adds a Google Meet link. Returns the Meet link and attendees.

Inputs: start (required), title (required), end, meet, +2 more.

create_habitAInspect

Add a habit (something to tick off, with a streak) or a routine (planned time on the calendar, like Lunch; not an agent routine, which is create_routine). Always personal. Defaults as in Caddie: a habit 30 minutes at 07:00 on weekdays, a routine 45 minutes at 12:30 every day.

Inputs: name (required), days, kind, times, +1 more.

create_linear_issueAInspect

Create an issue in the user's Linear through Caddie's Linear connection. team is a team key like ENG (default: their first team); assignee is a name or email in that team (from an agent's own turn inside Caddie, leave it out: assigning is refused there); priority is urgent, high, normal or low (or Linear's 0-4: 0 none, 1 urgent, 2 high, 3 normal, 4 low).

Inputs: title (required), team, assignee, priority, +1 more.

create_noteAInspect

Create a note in Caddie. content is Markdown: # headings, - bullets, 1. lists, bold, | tables |, links, pictures, and '- [ ] something' lines become checklist items in the note (not the user's To-dos). To give the user a To-do, use create_task (with note: this note's id to link it); put decisions you need from the user in your reply. To change a note you've made or shared, edit it in place (update_note or append_to_note). Never make a new note and delete the old one: its share link is what the user has sent to people, and it would stop working. If a note shared in the last few days has this title, nothing is made: the answer gives that note's id to update instead.

Inputs: title (required), content (required), separate, workspace, +1 more.

create_taskAInspect

Add a task. Without a date it goes to the Inbox; with a date (YYYY-MM-DD, optional time HH:MM) it's planned on that day. Optionally a priority, a due date, a list (someday, week), subtasks, the note it came from, a Linear issue, and in a team workspace who it's for (assignee).

Inputs: title (required), due, date, list, +9 more.

create_video_noteAInspect

Make a video note from a YouTube video or an X post with a video, on the user's Mac, as pasting the link in Caddie does: the video, its transcript (captions, or transcribed on the Mac) and notes written from it. Returns the note's id once it's made (the transcript and notes may still be coming), else that it's being made.

Inputs: url (required), workspace, collection.

decision_logAInspect

Write down a real choice right after you make it, so this agent's later runs follow it instead of working it out again: who someone is on an account, which of several matches you picked, which account, channel or approach you used when more than one would do, a default the user set. Not narration of steps, and not a choice the request already made for you. decision: one line, the conclusion ("Anupama on Slack is anupamadpverma@gmail.com"), 200 characters at most. why: what settled it, 300 at most. about: 1 to 4 short names of the people, accounts or topics ("Anupama Verma", "Slack"). evidence: "seen" (you saw it in the data), "inferred" (your best reading of it) or "said" (the user told you). rejected: the options you turned down. replaces: the id of an entry (decisions_read) this one overrides. A decision the user marked wrong or deleted is refused (the same text, or the same email, handle or number about the same people). from: your own "agent:task:key" (required inside Caddie); from outside Caddie, agent instead, and it's logged as the user's, via this client. Up to 20 an hour from one task, and 20 an hour from outside Caddie into one agent's log; 60 an hour into one agent's log in all.

Inputs: why (required), about (required), decision (required), evidence (required), +4 more.

decisions_readAInspect

What this agent decided before, and why: its Decisions log (one line each: who a person is on which account, which account or approach to use, who gets what), newest first, 20 at most. Read it before you choose a recipient, an account, a channel or an approach that may have been settled already, and follow what's there instead of searching again (or replace it with decision_log if it's wrong now). about: words for the people, accounts or topics ("Anupama Slack"); without it, the newest. Your instructions may already list the ones that fit this task. from: your own "agent:task:key" from your instructions; from outside Caddie, agent (its name or id) instead. include_replaced: the ones a later decision overrode too.

Inputs: from, about, agent, include_replaced.

delete_collectionAInspect

Delete a collection, not its notes: each note in it goes to its next collection, or else the Inbox (as Delete collection in Caddie). Only when the user asked to.

Inputs: name (required), workspace.

delete_eventAInspect

Delete a Google Calendar event (id, calendar_id and account_id from list_events). This can't be undone from Caddie: only delete when the user asked to. From an agent's own turn inside Caddie it's refused. A repeating event loses only this occurrence unless series is true (then the whole series goes).

Inputs: id (required), calendar_id (required), series, account_id.

delete_habitAInspect

Delete a habit or routine (kept for 30 days on the server, so it can be brought back if needed). Only when the user asked to.

Inputs: id (required).

delete_noteAInspect

Delete a note. It's kept for 30 days on the server, so it can be brought back if needed. Its tasks stay. Only delete when the user asked to. To change a note you've made or shared, edit it in place (update_note or append_to_note). Never make a new note and delete the old one: its share link is what the user has sent to people, and it would stop working. A shared note's public link stops working when it's deleted: that's refused until the user confirms, then pass confirm: true.

Inputs: id (required), confirm, workspace.

delete_routineAInspect

Delete one of the user's routines for good (list_routines). Only when the user asked; pause_routine stops it and can be undone. From an agent's own turn inside Caddie it's refused: pause it instead.

Inputs: routine (required), agent.

delete_rowsAInspect

Delete rows by id. The user can undo it from the table's History in Caddie. Only delete when the user asked to.

Inputs: ids (required), table (required), workspace.

delete_taskAInspect

Delete a task (kept for 30 days on the server, so it can be brought back if needed). To finish a task, use update_task with done: true instead.

Inputs: id (required), workspace.

find_free_timeAInspect

Free time on a day (default today; from now on, if today) between calendar events you're going to (not declined, not marked Free), planned tasks and habits, in the user's time zone. Returns slots as HH:MM-HH:MM at least minutes long, and what's busy. A Busy all-day event (a trip) leaves none.

Inputs: date, between, minutes.

followup_actAInspect

Settle one Get it done row on a call note, as the user's own Done, Dismiss and Undo buttons do: "done" (the user did it already; an open or failed row), "dismiss" (not needed; an open or failed row) or "reopen" (open again a row marked done by hand or dismissed). It only changes the row's state: nothing is run, sent or paid. A payment can't be marked done (only the user marks a payment paid), and one marked paid can't be reopened. Only when the user said so, or it's plainly done. row: the row's id from followups_list (or its exact title).

Inputs: row (required), note (required), action (required), workspace.

followups_listAInspect

A call's Get it done rows (the follow-ups Caddie worked out from it), or, without note, the open ones across the last 14 days' calls in one workspace (workspace; default the personal Caddie: a team's calls need its workspace). Each row: id, title, where it goes (dest, and service for an agent: Slack, Gmail, a coding agent…), to, owner ("me" is the user), state (open, failed, running, waiting, done, kept as a task for later, dismissed), result or error, and payment: true for a payment. status: "open" (still to do: open, failed, running or waiting), "done" (done, later or dismissed) or "all"; default "all" for one note, "open" without. mine: only the user's own rows. Read only: followup_act changes a row's state.

Inputs: mine, note, status, workspace.

get_data_tableAInspect

A data table's columns (name, type, select options, which one is unique, which is the row title), its row count and 5 sample rows. Read this before adding or changing rows so values fit the columns.

Inputs: table (required), workspace.

get_noteAInspect

Read one Caddie note in full, as Markdown that update_note takes back (tables, links and pictures included; a pasted picture reads as alt, which update_note turns back into the same picture).

Inputs: id (required), workspace.

get_transcriptBInspect

Read a meeting note's transcript (who said what, with times from the start of the call), or a video note's (what's said, with times from the start of the video).

Inputs: id (required), workspace.

growth_libraryAInspect

Search Caddie's product and growth library: tips from 2026 episodes of Lenny's Podcast, Subversive, Superwall and Sub Club, and A/B test results from apps (abtest.design), on paywalls, pricing, trials, onboarding, retention, acquisition, creators, ads and product strategy. Each tip has who said it, the evidence (numbers, test results) and a link to the moment it was said. queries: up to 6 keyword searches at once (e.g. ["paywall annual plan anchoring", "trial length"]); show narrows to one source. Use it to advise on product and growth, and to audit a screen, flow or page (the audit_screen prompt says how); cite tips with their links.

Inputs: queries (required), show, limit.

invite_memberAInspect

Invite someone to a team workspace by email (Caddie emails them a join link, good for 14 days). role: "member" (default) or "admin". Only a workspace's owner and admins can invite, from a confirmed email address, 50 a day. Only when the user asked for this person to be invited. From an agent's own turn inside Caddie it's refused: ask the user.

Inputs: email (required), workspace (required), role.

journal_readAInspect

Read the user's journal (always personal): one day (date, default today) or the days from-to (YYYY-MM-DD, up to 92 days), each with its text and one-line summary. Days with nothing written are left out.

Inputs: to, date, from.

journal_writeAInspect

Write in the user's journal for a day (default today). text is Markdown, as in create_note. mode append (default) adds it after what the day has; replace writes the day's whole text over. Only when the user asked you to write in their journal.

Inputs: text (required), date, mode.

linear_commentAInspect

Comment on a Linear issue as the user (their Linear connection; Markdown). issue: its key ("ENG-123"). Its subscribers are notified, so only what the user would say there.

Inputs: body (required), issue (required).

linear_cyclesAInspect

The user's Linear cycles (sprints): the previous, current and next one per team, with number, start and end dates and progress. team is a key like ONC2 (default: all teams).

Inputs: team.

linear_issuesAInspect

Read issues from the user's Linear through Caddie's Linear connection, newest activity first. All filters optional: text (in title or description), team (key like ONC2), assignee ("me" or a name or email), state (backlog, unstarted, started, completed, canceled, or a state name like "In Review"), cycle (current, next, previous). Each issue has its id (ONC2-123), title, state, assignee, priority, due date, cycle with dates, project and url.

Inputs: team, text, cycle, limit, +2 more.

linear_queryAInspect

Run any read-only Linear GraphQL query through Caddie's Linear connection, for what linear_issues and linear_cycles don't cover (projects, comments, labels, a single issue by id: issue(id: "ONC2-123") { title description comments { nodes { body user { name } } } }). Mutations are refused.

Inputs: query (required), variables.

linear_update_issueAInspect

Change a Linear issue through the user's Linear connection: state (a workflow state's name in its team, "In Progress", "Done"), assignee (a name or email in its team, "me", or "none" to unassign), priority ("urgent", "high", "normal", "low", "none" or 0 to 4), title. issue: its key ("ENG-123"). Only what you give changes. A state or assignee change notifies people, so from an agent's own turn inside Caddie it's refused: ask the user.

Inputs: issue (required), state, title, assignee, +1 more.

list_agentsAInspect

The user's other agents in Caddie: what each is for, what it's working on, and whether its Mac is on now, to pick one for ask_agent. A list; when the user has more agents than fit in one read, { agents, partial: true, note } with some of them.

Inputs: no named parameters.

list_collectionsBInspect

The collections (folders) notes are kept in, with how many notes each has.

Inputs: workspace.

list_data_tablesBInspect

The user's data tables: structured, typed tables (an outreach registry, a CRM, a reading list) that you read and change row by row. Use these instead of a table inside a note or a spreadsheet whenever you keep records. Without workspace it lists tables everywhere the user is.

Inputs: workspace.

list_eventsAInspect

Calendar events from the user's connected Google calendars between two dates (YYYY-MM-DD; default today and the next 7 days). Each has an id, calendar_id and account_id for update_event and delete_event.

Inputs: to, from.

list_habitsBInspect

The user's habits and routines (always personal): days, times, and for habits whether they're done on a date (default today) and the streak.

Inputs: date.

list_meetingsAInspect

The user's recorded calls (meeting notes), newest first: each one's id, title, date and time, minutes, people, a one-line summary from the note, how many transcript lines it has and its follow-ups (open, done, dismissed). from/to: days (YYYY-MM-DD); person: someone on the call (by name, in its people or a speaker); query: words in the title, people or note (all of them). Read one with get_note or get_transcript, its follow-ups with followups_list. Secret notes show their title only.

Inputs: to, from, limit, query, +2 more.

list_membersAInspect

A team workspace's members (name, email, role: owner, admin or member) and, for its owner and admins, the invites waiting. workspace: its name or id (list_workspaces).

Inputs: workspace (required).

list_routinesAInspect

The user's routines, as { routines, partial } (partial: some agents weren't read): each one's id, name, the agent that runs it, its schedule (days as "mon"…), whether it's on (off when paused or its task is done), when it last ran, when it runs next and the start of its instructions. Read only; create_routine proposes a new one.

Inputs: no named parameters.

list_tasksAInspect

List tasks. filter: today | inbox (unscheduled To-dos, not Someday or Later this week) | upcoming | overdue | open (all not done) | done. In a team workspace each task says whose it is; mine: true keeps only the user's own and unassigned ones.

Inputs: mine, filter, workspace.

list_workspacesAInspect

The user's workspaces: their personal Caddie and each team workspace they're in (name, id, their role). Notes, tasks and collections tools take a workspace (a team's name or id); without it they use the personal one. Pick a team when the user names it or the work is the team's.

Inputs: no named parameters.

log_habitAInspect

Mark a habit done (or not done) on a date, default today. done marks every session of a habit with several times a day, and done:false clears the day; to log some of them, pass sessions (how many were done that day).

Inputs: id (required), date, done, sessions.

memory_readAInspect

What Caddie knows about the user ("What Caddie knows about you", a note they can edit): lines under "About you", "People", "How you like things done", "Keep an eye on". Your instructions already have it as it was when this turn started; read it again only after changing it.

Inputs: no named parameters.

memory_updateAInspect

Change what Caddie knows about the user, line by line, all or nothing. Save facts that will still matter in a month for any task: who they are, the people they work with and how each likes to hear from them, how they like things done, what to keep an eye on. Write facts, not orders ("Sainath wants Mixpanel numbers in Slack", not "Always send…"). Don't save task progress, one-off details, what you did today (that's in search_runs) or how to do a job (that's a skill). One fact a line, 300 characters at most; 4000 characters in all: when it's full, merge or remove lines in the same call. A line you change or remove is matched by a part of it.

Inputs: operations (required).

move_noteAInspect

Move a note into a collection (it becomes the note's main one; "Inbox" takes it out of all collections), and/or to another workspace with to_workspace (its tasks go with it; everyone in a team workspace sees it there, so from an agent's own turn inside Caddie that's refused).

Inputs: id (required), workspace, collection, to_workspace.

note_from_templateAInspect

Make a new note from one of the user's templates (notes marked "Use as a template"), on their Mac, as ⌘K › New from template does: a copy to fill in. Returns the new note's id.

Inputs: template (required), title, workspace, collection.

notify_userAInspect

Show the user a short line in Caddie's notch on their Mac (and the Planner's thread), as you (your agent's name and face when you're one of their Caddie agents). For something they should see now, not for every update: at most 10 an hour across all callers. buttons: up to 2 short answers they can tap; when you're running in one of their Caddie agent tasks, the tapped label comes back to that task as their reply (a typed reply too). Otherwise the tap just shows. Needs Caddie open on the Mac.

Inputs: text (required), ref, buttons.

organize_agentsAInspect

Organise the user's agents on Caddie's Agents page: sections (groups like "Creators" or "Growth") and names. action: "list_sections" (each section with its agents, and No section); "create_section" (section: its name); "rename_section" (section, name: the new name); "delete_section" (section; its agents go to No section); "move" (agents: names or ids, section: where to, a new name makes it, "none" for No section); "rename_agent" (agent, name). Changes show on the user's Mac and phone at once. Use this instead of telling the user to drag agents around.

Inputs: action (required), name, agent, agents, +1 more.

pause_routineAInspect

Pause one of the user's routines (paused: true) or turn it back on (paused: false), as its switch on the Agents page does. Turned on, it next runs at its next slot from now. routine: its id or name (list_routines).

Inputs: paused (required), routine (required), agent.

phone_askAInspect

Ask the user a short question on their iPhone, with up to 4 answers to tap (default Yes / No). For when you need their OK or a choice and they may be away from the Mac. It waits up to 45 s by default (wait_seconds, up to 50); if they answer later, the answer comes back to this task as a message (give from; one of Caddie's own agents' turns is known without it), or phone_result has it.

Inputs: question (required), why, from, options, +1 more.

phone_locationAInspect

Ask the user's iPhone where they are (they tap Share on the phone; Caddie's iPhone app has to be open or opened). Only when where they are changes what you do (travel time, a nearby place, the right time zone). It waits up to 45 s by default (wait_seconds, up to 50); if they answer later, the answer comes back to this task as a message (give from), or phone_result has it.

Inputs: why (required), from, wait_seconds.

phone_photoAInspect

Ask the user to take a photo with their iPhone (a whiteboard, a receipt, a document). Returns a link to the picture once they've taken it. It waits up to 45 s by default (wait_seconds, up to 50); if they answer later, the answer comes back to this task as a message (give from), or phone_result has it.

Inputs: why (required), from, wait_seconds.

phone_resultCInspect

The answer to a phone_location, phone_ask or phone_photo that was still waiting.

Inputs: request (required).

pin_noteCInspect

Pin a note to Caddie's sidebar (it goes last among the pinned).

Inputs: id (required), workspace.

plan_dayAInspect

Run Plan my day in Caddie on the user's Mac: the Planner agent proposes a plan for the day in its chat and asks before changing anything (without a Planner that can run there, today gets Caddie's quick plan in the Planner's thread). Says where the plan is.

Inputs: date.

query_rowsAInspect

Rows of a data table as JSON objects keyed by column name, plus each row's id (for update_rows and delete_rows). where: { "": value } matches exactly (case-insensitive; select columns by option name; a multi-select contains it), or an operator: {"not": v}, {"in": [a, b]}, {"contains": "text"}, {"empty": true}, {"gt"|"gte"|"lt"|"lte": n or "YYYY-MM-DD"}. All conditions must match. sort: [{ column, desc }]. Pages: pass the cursor you got back for the next page (null: no more).

Inputs: table (required), sort, limit, where, +2 more.

rename_collectionCInspect

Rename a collection; its notes go with it.

Inputs: to (required), name (required), workspace.

report_errorAInspect

Send an error report to Harsha, who builds Caddie, when a Caddie tool or the Caddie app fails in a way that looks like a bug (not for wrong input you can fix yourself). message: the error text; where: which tool or screen; context: what you were doing (no note contents, keys or personal data); stack if you have one. Limited per day.

Inputs: message (required), stack, where, context, +1 more.

restore_noteAInspect

Bring back a deleted note (kept 30 days after it's deleted, in Caddie or by delete_note). Without id it lists the recently deleted notes (id, title, when). Its tasks aren't linked to it again.

Inputs: id, workspace.

search_notesAInspect

Search Caddie notes by words in their title or text, imported notes included. Returns ids, titles and a snippet. An empty query lists the most recent notes.

Inputs: limit, query, workspace.

search_runsAInspect

Search what the user's agents did and said before (every agent's chats in Caddie, routines included). Use it when the user mentions something from earlier, or before redoing a lookup another run may have done. query: words to look for (results: the tasks that match, best first, with the lines that matched); agent and task (from a result): read that chat; nothing: the latest tasks. days: only the last N days. A chat read back has why: the decisions each reply made. decisions: true searches the agents' Decisions logs instead (what each decided and why; query and agent narrow it). Findings agents saved in notes aren't here: search_notes has those.

Inputs: days, task, agent, limit, +2 more.

search_transcriptsAInspect

Find what was said on the user's calls: transcript lines that have all the words in query (case-insensitive; a speaker's name counts), newest calls first, each with the note's id and title, the time into the call (m:ss), the speaker, the line and the line before and after. person, from, to narrow which calls (person: on the call). Searches the newest 150 calls at most and says partial when there were more. Secret notes are never searched.

Inputs: query (required), to, from, limit, +2 more.

set_agent_accessAInspect

Change one of the user's agents' access: "supervised" (no commands or file edits; its connected tools still work), "edits" (edits files, asks before each command) or "full" (runs commands without asking). Lowering always works. More access only when the user asked for it, and never from an agent's own turn inside Caddie: there it's refused, so ask the user to set it on the Agents page instead.

Inputs: agent (required), access (required).

share_noteAInspect

Make a public link to one of the user's Caddie notes, with the same options as Share in the app: include_tasks (the note's tasks and its call's follow-ups, folded under the page), include_transcript (a recorded call's transcript), description (the link preview's line), invite (email addresses to send the page to; each gets an email with it). A video note's page shows its video. Anyone with the link can read it, not edit; it stays current as the note changes. Called again on a note that's already shared, it keeps the same link and refreshes the page. To change a note you've made or shared, edit it in place (update_note or append_to_note). Never make a new note and delete the old one: its share link is what the user has sent to people, and it would stop working. stop: true turns the link off. id: the note's id (search_notes finds it); workspace: as for get_note. Only when the user asked for the note to be shared or sent. From an agent's own turn inside Caddie it's refused: ask the user instead. Secret notes, and notes kept only on the user's Mac, can't be shared. The answer's tasks_shared says how many tasks the page shows (tasks show when create_task was given note: this note's id).

Inputs: id (required), stop, invite, workspace, +3 more.

skill_saveAInspect

Save how to do a job so you (and the user's other agents) do it right next time: after work that took several tries or steps, when the user corrected how you did something, or when a skill you followed turned out wrong. From an agent's own turn only new skills can be saved: changing an existing one needs the user, so tell them what should change rather than saving a near-copy. Outside a turn, to change one, read it (skill_view), then give old (an exact piece of its text) and new. To make one or rewrite it: name (what the job is, 2 to 5 words, never a date or one person's case), use_when (one line: when it applies) and body (Markdown: ## Steps as numbered steps, ## Watch out for what went wrong). No keys or passwords.

Inputs: name (required), new, old, body, +1 more.

skills_listAInspect

The user's skills: how to do jobs that come up again (notes in Caddie's Skills collection, written by agents or by them). Your instructions already list them by name; this lists them again with links.

Inputs: no named parameters.

skill_viewAInspect

Read a skill in full before doing that job. Do this whenever a skill's "use when" fits what you're asked, even partly.

Inputs: name (required).

slack_sendAInspect

Send a Slack message as the user, in their DM with one person in their Slack workspace (to: the person's name; their full name, or a first name only one person has). Channels can't be sent to: the user's Slack connection can't look them up. Only a message the user approved, to the person they meant; it can't be unsent. From an agent's own turn inside Caddie it's refused: draft it for the user instead.

Inputs: text (required), to, channel.

start_focusAInspect

Start a focus session on one of the user's tasks in Caddie on their Mac (the notch's timer and check-ins), as their Focus on this button does. If another session is running, the Mac asks them before switching; if they use the pre-focus ritual, it opens first. Only when they asked for it, or agreed.

Inputs: task (required), minutes.

task_approveAInspect

For clients outside Caddie, as the user's explicit OK or no on what waits in a task (task_status › waiting_for_ok): a draft to send or post, a reply that asks to send, an agent or routine an agent proposed (Make it / Not now), work going somewhere with more access. Only when the user told you to decide this: never OK a send they haven't seen and agreed to. approve: true (send / make it / allow) or false (don't / not now). item: which one, its id from waiting_for_ok (required, so the answer goes on what the user saw; the same item twice is answered once). text: send this instead of the draft (the user's edit). note: a line for the agent. It shows in the chat as the user's OK, via this client.

Inputs: item (required), task (required), agent (required), approve (required), +2 more.

task_replyAInspect

For clients outside Caddie acting for the user: say something in an agent's existing task, with all of its context (an answer to its question, the next step). It's the user's message there, shown as sent via this client, and runs on the agent's Mac (queued if it's busy; a done task opens again). To OK a draft or a proposal, use task_approve. wait_seconds (up to 50) waits for its reply to this message. Up to 30 messages and OKs an hour (task_stop is never held back).

Inputs: task (required), agent (required), message (required), wait_seconds.

task_statusAInspect

For clients outside Caddie: one agent task's state (working, queued, waiting_for_mac, waiting_for_ok, needs_user, failed, stopped, idle, done), its last message and last reply, the steps of a turn running now, and waiting_for_ok: drafts and proposals that wait for the user's OK (each with an id for task_approve). wait_seconds (up to 50): while it's working or queued, wait here until it isn't. task: its id or title (agent_tasks, search_runs, ask_agent give them).

Inputs: task (required), agent (required), wait_seconds.

task_stopBInspect

For clients outside Caddie acting for the user: stop an agent's task, the turn running now and the messages waiting in it, as Stop on the Agents page does.

Inputs: task (required), agent (required).

task_waitAInspect

task_status that waits (50 s by default, 50 at most) while the task is working or queued, and returns as soon as it isn't (or at once when its Mac is off: waiting_for_mac). Call it again to keep waiting.

Inputs: task (required), agent (required), wait_seconds.

unpin_noteCInspect

Unpin a note from Caddie's sidebar.

Inputs: id (required), workspace.

update_agentAInspect

Change one of the user's Caddie agents: instructions (what it's for and how it works, written to it; replaces them), name, model (claude-code: "sonnet", "opus", "haiku"; codex: "gpt-5.5", "gpt-5.5-mini"; "default" for the default), provider ("claude-code" or "codex"; changing it resets the model) and folder (its working folder, "~/code/app"; "" for none). Only what you give changes. From an agent's own turn inside Caddie, instructions are never changed, nor the folder of an agent that (or one of whose tasks) has Full access or Edits, nor a Full-access agent's provider or model: ask the user. Access: set_agent_access. Sections: organize_agents.

Inputs: agent (required), name, model, folder, +2 more.

update_eventAInspect

Rename or move a Google Calendar event (id, calendar_id and account_id from list_events). start/end are ISO date-times with offset; with start alone it keeps its length (or give minutes). Guests are told about changes, so from an agent's own turn inside Caddie only an event without guests is changed. A repeating event changes only this occurrence unless series is true (then every event in the series moves by as much).

Inputs: id (required), calendar_id (required), end, start, +4 more.

update_habitBInspect

Change a habit or routine (id from list_habits): its name, kind, days, times or minutes. New days count from today on, so its streak isn't broken.

Inputs: id (required), days, kind, name, +2 more.

update_noteAInspect

Rename a note, or replace its whole text with new Markdown content (as create_note takes it). The note keeps its id, and if it's shared its public page shows the new version at the same link. To change a note you've made or shared, edit it in place (update_note or append_to_note). Never make a new note and delete the old one: its share link is what the user has sent to people, and it would stop working. To rewrite: get_note, change its text, send the whole of it back; tables and pictures in get_note's text (| tables |, alt) come back as they were. Content that leaves out a picture or table the note has is refused, unless replace: true (dropping them is what the user wants). To add at the end, append_to_note.

Inputs: id (required), title, content, replace, +1 more.

update_routineAInspect

Change one of the user's routines (list_routines): instructions (what each run does; replaces them), schedule, name. Only what you give changes. routine: its id, its whole name, or a part only it has; agent narrows it to one agent's. Changed from an agent's own turn inside Caddie, its runs ask before they send or post anything from then on.

Inputs: routine (required), name, agent, schedule, +1 more.

update_rowsAInspect

Change cells of existing rows by id (ids from query_rows): updates is [{ id, set: { "": value } }]. Only the cells in set change; the rest of the row stays as it is, so other people's and agents' edits to other cells are kept. null empties a cell. All or nothing, up to 500 a call.

Inputs: table (required), updates (required), workspace.

update_taskAInspect

Change a task: rename it, move it to a date/time, change its length, set its status (todo, progress = in progress, review = in review, done), or mark it done/undone. An agent working on a task handed to it sets progress when it starts and review (or done) when it's finished. Also its priority, due date, list, subtasks, note, Linear issue and (in a team) assignee; fields left out stay as they are.

Inputs: id (required), due, date, done, +12 more.

upsert_rowsAInspect

Update-or-add by the table's unique column (key: that column's name, e.g. "Email"): a row whose key value is already in the table has the cells you give set (others stay); the rest are added. The safe way to keep a registry in step without making duplicates. All or nothing, up to 500 a call.

Inputs: key (required), rows (required), table (required), workspace.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Remote MCP server that lets AI assistants read tracked competitive intelligence — competitor news, reviews, website changes, social posts and ads — and act on it by managing projects, competitors, battle cards, reports and canvases. Every answer carries a source and a date, and write actions only publish when explicitly shared.
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables brand visibility monitoring across major AI platforms like ChatGPT, Claude, Gemini, and Perplexity. It allows users to track visibility scores, analyze competitor data, and receive actionable insights to improve AI-generated brand recommendations.
      16
      11 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Browse IndustryLens's published competitive-intelligence reports and head-to-head competitor comparisons from any AI agent — real, source-backed data.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources