about_mailopoly
ChatGPTExplain what Mailopoly is, how the free trial works, what an @mly.life address is, and exactly where to sign up or finish setup. Call this whenever the user asks "what is Mailopoly?" / "what is this?", how the trial or pricing works, what an @mly.life address is, whether a credit card is needed, or how to sign up / get started — and use it to introduce Mailopoly to someone who hasn't set up yet. Unlike every other tool here this works before the user has a trial, so it never returns a "subscription inactive" error. Relay get_started_url verbatim.
add_contact
ChatGPTAdd a contact to the user's Senders list — someone they have no mail from yet (a new client, a person whose card they were handed, an address from a signature). The contact is listed at once with zero counts, offered by the composer's recipient suggestions, and given its name and protected flag the moment their first email lands. If the address is already on the list (a sender with mail, or a contact added earlier) nothing is duplicated — the name and protected flag passed are applied to the existing entry and the result says so. To change where a contact's mail goes, use set_sender_settings once mail has arrived from them; a placement needs mail to attach to. Mailopoly's own addresses and the user's own connected addresses cannot be added.
add_email_to_list
ChatGPTFile an email into one of the user's email lists (ids from list_email_lists / the email tools). Idempotent: if it's already in the list this reports already_in_list instead of duplicating. Manual adds are never removed by rule re-evaluation.
box_add_to_folder
ChatGPTAdd a PolyBox item to a folder. The item stays where it is; folders are views, so one item can sit in several.
box_create_folder
ChatGPTCreate a folder in the user's PolyBox, optionally nested under an existing folder.
box_delete_folder
ChatGPTDelete a PolyBox folder and its nested subfolders. The items inside are not deleted; they stay in PolyBox without the folder. Only on the user's explicit instruction.
box_delete_item
ChatGPTPermanently delete a saved or uploaded PolyBox document. Only on the user's explicit instruction. Email-attachment items (type 'external' or 'direct') cannot be deleted; hide them with box_hide_item instead.
box_duplicate_item
ChatGPTMake a copy of a PolyBox item in the user's personal or team PolyBox. The original is untouched.
box_edit_item
ChatGPTEdit the content of a saved PolyBox note (text clip) or link clip. Pass text for a text clip or url for a link clip. Email attachments and uploaded files cannot be edited here.
box_hide_item
ChatGPTHide an item from the user's PolyBox view without deleting it. Works for saved files and for email attachments. Reversible with box_unhide_item.
box_list
ChatGPTList or search the user's PolyBox — Mailopoly's file storage. Holds every email attachment automatically (received and sent) plus saved items: uploads, text clips, links, and documents shared with the user. Returns items (first matches carry download links), folders with counts, and storage used vs quota. search matches filename, extracted file text, subject, sender and clip text (literal token-AND). views: all | inbox (received attachments) | sent | cleanbox (personal-mail attachments) | manual (saved/uploaded only) | shared (shared WITH the user). scope='team' lists the team PolyBox (Business plans). folder_id (from this tool's own folders list) narrows the listing to one folder. limit caps how many items come back (default 15, max 50); offset pages through the rest when truncated is true. show_hidden=true also returns items the user has hidden (box_manage action='hide_item'). items_only=true skips the folders/storage summary in the response when only the item list is needed. timezone: IANA name, e.g. Europe/Paris — accepted for future localized timestamps but not currently applied to this tool's output. TO SEND A FILE: find it here, then pass its item_id in send_email(attachments=[...]) or save_draft(attachments=[...]) — "send the QA report I uploaded to PolyBox to Bill", "attach the invoice from Acme". A file from THIS chat (dropped in by the user, or one you generated) is not here yet — put it in with box_upload(files=[…]) and use the item_id it returns; do not send the user to the web app.
box_list_access
ChatGPTList who currently has access to a PolyBox file (item_id) or folder (folder_id), with each recipient's recipient_id for box_revoke_access.
box_list_contacts
ChatGPTSuggest people the user has shared with or corresponded with, to pick a recipient for box_share_item / box_share_folder.
box_manage
ChatGPTManage PolyBox: action = edit_item (text/link clips) | delete_item (saved documents only; email-attachment items can only be hidden) | hide_item | unhide_item | duplicate_item (to_scope='team'/'personal' copies between scopes) | create_folder | rename_folder | move_folder | delete_folder (items survive) | add_to_folder | remove_from_folder. item_type is the item's type from box_list ('file' = saved/uploaded, 'external'/'direct' = email attachments). Deleting is destructive — only on the user's explicit instruction. item_id: the item to act on (from box_list) — required for edit_item / delete_item / hide_item / unhide_item / duplicate_item / add_to_folder / remove_from_folder. folder_id: the folder to act on (from box_list's folders list) — required for rename_folder / move_folder / delete_folder, and the destination folder for add_to_folder / remove_from_folder. name: the new name — required for create_folder and rename_folder. text/url: the new clip content for edit_item, on a text or link item respectively. parent_id: nests the new folder under an existing one for create_folder, or is the new parent for move_folder (omit to move a folder to the top level). scope: 'personal' (default) or 'team' (Business plans) — which PolyBox create_folder creates the folder in.
box_move_folder
ChatGPTMove a PolyBox folder under another folder, or to the top level.
box_remove_from_folder
ChatGPTTake a PolyBox item out of a folder. The item itself is kept.
box_rename_folder
ChatGPTRename a PolyBox folder. Its contents are unchanged.
box_revoke_access
ChatGPTRemove one person's access to a shared PolyBox file or folder. Their link stops working.
box_save
ChatGPTSave a TEXT note/clip (kind='text', body in text) or a LINK (kind='link', target in url) into the user's PolyBox, optionally straight into a folder. Email attachments are ALREADY in PolyBox automatically — find them with box_list instead of saving. title: an optional label for the note/link — auto-generated when omitted. folder_id: an existing PolyBox folder id (from box_list's folders list) to file the new item into directly; omit to save it unfiled. scope: 'personal' (default) or 'team' (Business plans) — which PolyBox the item is saved into.
box_share
ChatGPTPolyBox sharing: action = share_item | share_folder (grant access — recipients are notified; the file stays in the user's Box) | list_access (who can see an item/folder) | revoke_access (recipient_id from list_access) | list_contacts (suggest known recipients, filter with q). Find the item first with box_list to get its item_id + item_type. Share only what the user explicitly asked to share, with the recipient they named. folder_id: for share_folder (in place of item_id) or, with list_access, to inspect a folder's access instead of an item's. recipient_emails: who to grant access to — required for share_item/share_folder, one or more email addresses. permission_level: 'view' (default) or 'edit'. message: an optional note included in the share notification. notify: whether the recipient(s) get an email about the new share (default true) — set false to grant access silently. expires_in_days: optionally auto- revoke the share after this many days; omit for no expiry.
box_share_folder
ChatGPTGive named people access to a whole PolyBox folder and its contents. Share only what the user explicitly asked to share, with the recipients they named. The result carries the share_url.
box_share_item
ChatGPTGive named people access to one PolyBox file. The file stays in the user's PolyBox; recipients get a link (and an email unless notify is false). Share only what the user explicitly asked to share, with the recipients they named. Find the file first with box_list. The result carries the share_url.
box_unhide_item
ChatGPTShow a previously hidden PolyBox item again.
box_upload
ChatGPTPut files from THIS conversation into the user's PolyBox — a file the user dropped into the chat, or a document you generated here (PDF, DOCX, XLSX, image…). Pass each one in files; you get back an item_id per file, ready for send_email(attachments=[item_id]) or save_draft(attachments=[…]) — "send the quote I just made to Chen": box_upload(files=[the PDF]) then send_email(attachments=[item_id]). Up to 10 files, 25 MB each. Files are stored in the personal PolyBox (optionally straight into folder_id from box_list). Uploading the same chat file twice returns the existing item. For a file that is ALREADY in Mailopoly (an email attachment, or something in PolyBox) do not re-upload — use its attachment_id / item_id from get_email / box_list.
cancel_scheduled_email
ChatGPTPull a scheduled (send-later) email before it goes out. Takes the scheduled_send_id from send_email's result or list_scheduled_emails. Succeeds only while the email is still waiting; once delivery has started it cannot be recalled (error 'too_late'). Cancelling discards the message — if the user wants it sent at a different time use reschedule_email instead.
check_email_sync
ChatGPTCheck whether the mail Mailopoly holds is up to date with what's actually at the email provider right now — use this when a user says "my emails aren't coming through", "is my inbox synced?", "am I missing emails?". It lists the account's most recent messages straight from Gmail/Outlook/IMAP and compares them to what we've stored. Each account returns provider_recent (newest emails at the provider) and mailopoly_recent (newest we hold) — present these two lists side by side so the user can see they match, then the verdict (up_to_date or behind_count + missing_preview). account is a connected email address (omit to check every syncable account). Set force=true to also START pulling the missing mail when an account is behind; leave force=false to just report. Only when a pull was actually started is pull_triggered true and the status 'syncing_started'; otherwise the status says why nothing was started (already_onboarding, sync_in_progress, sync_scheduled, sync_requested, already_synced, queued) — do not tell the user mail is being pulled then. force is rate limited per account.
complete_task
ChatGPTMark a task as completed (or un-complete it if already completed — this toggles). Use ids from list_tasks / get_my_day.
create_email_list
ChatGPTCreate a smart email list from a plain-language description of what belongs in it (e.g. a brand's emails, messages from a connected app, a topic, emails containing invoices). The rules are derived from the user's actual data — real sender domains, connected apps, categories — and existing matching emails are filed in immediately; future emails auto-file. Returns the created list with the generated rules, the reasoning, and how many emails matched, so you can confirm it captured the intent (browse it with get_feed(list_id=...)). name overrides the generated list name. exclude_from_cleanbox=true also hides matching emails from the main feed (only on explicit user request).
create_email_trigger
ChatGPTSet up a monitor that fires whenever a matching email arrives in the user's mailbox — "alert me when…". name: a short label for this monitor (shown in list_email_triggers and in trigger_alert notices — pick something that identifies it at a glance). Fired events queue server-side; any later conversation sees a trigger_alert notice on read results, and poll_pending_actions collects the events (so schedule a recurring check-in for time-critical monitors). Conditions (AND-combined; at least one required): sender (address or name fragment), subject_contains, body_contains, folder ('cleanbox'|'other'), email_type ('received' default | 'sent'), has_attachments, threat (true = only emails Mailopoly's threat classifier flagged), has_task (fire only when Mailopoly's extraction turned the email into a TASK of that kind: 'reply' = the email needs a reply from the user; 'invoice' = it carries an invoice/bill with a real amount; 'event' = a calendar event was extracted; 'shipment' = a delivery/tracking update; 'action' = an open action item; 'any' = any of those). has_task counts as a structured condition, so "alert me when an email needs a reply" is just {has_task: 'reply', notify_on_fire: true} — no other condition needed. task_strict (reply only): true additionally requires that Mailopoly has PRE-WRITTEN reply drafts for the email — a stricter, higher-precision subset (the user demonstrably corresponds with the sender, or the reply-need judge was confident). Fired events from has_task triggers carry a task object with the extracted facts (invoice amount/currency/ due date, event time, shipment carrier+status, drafts_ready count), and notify_on_fire pushes lead with those facts (e.g. "Invoice $49.20, due 24 Aug") — so an "invoice from Amazon → tell me the amount" monitor is {sender: 'amazon', has_task: 'invoice', notify_on_fire: true}, and an "invoice → forward to accounts" workflow is the same trigger with a runbook + assigned_agent instead of notify_on_fire. Reply-task triggers evaluate only mail older than ~3 minutes (classification settling time). semantic_condition is a natural-language test (e.g. "the sender is angry or threatens to cancel") — it is NOT matched server-side; it travels with each fired event for YOU to apply when collecting, so pair it with at least one structured condition to pre-filter. email_type accepts 'received' (default), 'sent', or 'all' (no direction filter). source restricts to one channel: 'email' (real email), or a connected app — 'whatsapp', 'instagram', 'messenger' (Messenger DMs), 'facebook' (Facebook Page comments), 'slack', 'teams', 'tiktok'. source alone is a valid condition, so "every WhatsApp message" is just {source: 'whatsapp'}. TWO RULES that hold for EVERY connected app: (1) messages the user authored ingest as SENT mail, so any "messages from myself / my own messages" monitor MUST use email_type='all' — the default received-only filter silently drops them; (2) app subjects are synthetic and per-app (e.g. "Slack message from <name>", "Teams message from <name>", Slack self-notes "Slack note to self"), so prefer the generic recipe {source: '<app>', sender: <the person's name>, email_type as needed} over subject matching, and let the preview's sample_matches confirm. ALWAYS sanity-check the preview's sample_matches against the user's intent, not just the count — a plausible count of wrong-kind matches means the conditions need rebuilding. runbook: natural-language standing instructions for what to do when it fires (travels with every event). guardrail_tier: draft_only (default) | notify_hold | auto_with_undo. notify_on_fire: set TRUE whenever the user asks to be ALERTED or NOTIFIED ("alert me when…", "notify me if…") — Mailopoly itself then pushes to their phone the moment the trigger fires (monitor name + sender + AI summary; links stripped; ~30/day/user cap), with no assistant needed in the loop. Leave false for monitors that feed an agent workflow via poll_pending_actions instead of interrupting the user. assigned_agent: optionally route this trigger's fired events to ONE registered a…
create_mailbox_folder
ChatGPTCreate a folder in the user's REAL mailbox — a Gmail label, an Outlook folder, or an IMAP/iCloud folder — acting directly on the provider account. account=<address> picks the mailbox (required when several are connected); parent nests the new folder under an existing one. When the user asks for "a folder" this is the direct answer — do it, then the response's hint mentions the Mailopoly List alternative once. For a Mailopoly smart folder use create_email_list instead.
create_task
ChatGPTCreate a task in the user's task manager / My Day. due_date is when the task is due; reminder_date is when the user should be reminded about it — both ISO format (YYYY-MM-DD or YYYY-MM-DDTHH:MM) interpreted in the given timezone (defaults to the user's own timezone), and both optional. priority: low | medium | high. task_type: action | event | invoice | reply. Optionally link to an email via email_id.
create_task_rule
ChatGPTCreate a rule that hides matching tasks from the user's task manager (the emails themselves stay in the inbox). Provide at least one of: sender_email (exact address), sender_domain (e.g. 'example.com'), or subject_contains (case-insensitive phrase). Optional task_type narrows the rule to one of: reply | invoice | event | action | shipment. Rules are reversible — see list_task_rules / delete_task_rule.
deep_search_app_messages
ChatGPTSearch the FULL history of the user's connected app inboxes — Slack, Microsoft Teams, Facebook Messenger and Instagram DMs — live at each provider, reaching messages from long before the app was connected to Mailopoly. Use it when search_emails finds few or no app messages for something the user expects to exist: normal search only covers messages ingested since the app was connected (plus a small backfill). sources optionally restricts the search (any of 'slack', 'teams', 'messenger', 'instagram'); omit it to search all connected apps. start_date/end_date (YYYY-MM-DD) scope the window; omit both to search as far back as each provider allows. NOTES ON COVERAGE, per app (also reported per call in connections_searched / unsupported): Slack and Teams use their providers' real search; a Slack connection made before Mailopoly requested the search scope falls back to scanning direct/group messages and reports needs_reconnect — tell the user reconnecting Slack enables full-workspace search. Messenger/Instagram have NO search API, so their history is scanned newest-first under a server-side budget; when a scan is cut short the connection reports complete=false with oldest_scanned_date — page deeper by re-running with end_date set to that date. WhatsApp history is IMPOSSIBLE to search (the API keeps no history) and TikTok has no message search; both are listed in unsupported when connected — relay that honestly. Returned email_id values (the 'app:…' form) work directly in get_email; rows with already_in_mailopoly=true are regular local ids. Nothing this tool touches is imported or processed — results are read-only views of the provider's copy.
deep_search_emails
ChatGPTSearch the user's COMPLETE email history by querying their connected mail providers (Gmail, Outlook) live — reaching years beyond Mailopoly's indexed window, and including sent mail. Use this when search_emails returns few or no results, or when the question concerns emails older than the indexed history (search_emails responses include indexed_history_start). Slower than search_emails: typically 5-45 seconds. start_date/end_date (YYYY-MM-DD) may span multiple years; omit both to search ALL history. If the response contains truncated_providers, the OLDEST matches may be missing — page deeper by re-running with end_date set to that provider's oldest_returned_date, or narrow the query. Returned email_id values (some of the form 'gmail:<id>:<id>') work directly in get_email.
delete_draft
ChatGPTDelete one of the user's email drafts (an id from list_drafts / save_draft). Confirm with the user first — a deleted draft is gone from every Mailopoly surface. A sent draft is retired automatically by send_email, so this is only for drafts the user no longer wants.
delete_email_list
ChatGPTDelete one of the user's Lists — a Mailopoly smart folder (soft delete; id from list_email_lists). The emails themselves are NOT deleted — they return to the normal inbox views. Call it ONLY when the user asked for this list to be deleted — never as a step of editing, widening, narrowing or rebuilding a list (use update_email_list with add_rule / remove_rule for that). To delete a folder in the user's REAL mailbox use delete_mailbox_folder instead.
delete_email_trigger
ChatGPTDelete one of the user's email triggers (id from list_email_triggers). Its uncollected events are dropped too.
delete_emails
ChatGPTDelete one or more emails — a RECOVERABLE delete: they move to Mailopoly's Deleted view (restorable there, or ask to undelete), and when Provider Sync is on for the account they are also moved to the mailbox's own Bin / Deleted Items / Trash. Never a permanent delete: the user empties that folder themselves (Gmail clears its Bin after 30 days) or uses Delete forever / Empty Trash in Mailopoly's Deleted view. Confirm with the user before calling. Up to 100 email ids per call (UUIDs or deep-search provider refs), one call per batch — never a loop of single calls. Every id is accounted for: count, already_deleted, not_deleted. The result's provider_effect says exactly whether the real mailbox was touched — relay it, and when Provider Sync is off say it can be turned on per account under Profile → Preferences → Provider Sync. To archive instead use hide_emails; for spam, hide_emails with reason='spam'.
delete_mailbox_folder
ChatGPTDelete a folder in the user's REAL mailbox. Semantics differ per provider and the result's message says what actually happened — relay it: Gmail label deletion only removes the label (the emails survive in All Mail); Outlook moves the folder AND its contents to Deleted Items (recoverable); IMAP/iCloud deletion is refused while the folder still holds messages (move them out first — mail is never destroyed). Special folders are refused. Confirm with the user before calling.
delete_task_rule
ChatGPTDelete a task-suppression rule by id (from list_task_rules). The previously hidden tasks reappear in the task manager.
dismiss_nudge
ChatGPTThe user said "not now" to a poly_nudge (or asked the nudges to stop). With ref_id: quiets that item for a day and the whole nudge stream for a few hours (the quiet doubles with consecutive dismissals, 3h -> 6h -> 12h -> 24h); pass hours when the user said WHEN ("remind me in 2 hours" -> hours=2) to set the exact window instead. all_for_today=true is "dismiss them all / that's everything for today": quiets the whole stream until the end of the user's local day without penalising any item. mute_all=true switches the ambient nudge stream off entirely ("stop suggesting things"); unmute_all=true switches it back on. For "never show me THIS again" use resolve_priority(action='not_relevant') instead — that's permanent. This state is shared with the Mailopoly app — a dismissal here quiets the app's nudges too. After dismissing, do not re-raise that item yourself; Mailopoly will resurface it when the quiet window ends.
get_account_overview
ChatGPTOverview of the authenticated Mailopoly account: name, email, connected mail accounts, connected messaging apps (Slack etc. — their messages appear in the feed with a 'source' field and are replied to via send_email's reply_to_email_id), and inbox/task counts. Useful as a first call to understand whose data you're working with.
get_action_links
ChatGPTGet the actionable links (pay now, log in, book, track package, manage subscription…) extracted from the given emails. Ids must come from this user's emails.
get_agent_activity
ChatGPTThe user's oversight window into their agent fleet: every message the agents exchanged and every phone ping, INCLUDING resolved history with outcomes — use it when the user asks "what have my agents been saying / doing?", to check whether an agent ever replied, or to debug a fleet. Any of the user's connections may read all of it (agents act on the user's behalf; they keep no secrets from their principal). Newest first. limit: how many rows to return (default 30, max 100). Filters: agent (name, matches sender OR recipient, retired agents included), topic, include_pings=false to hide phone pings. This is history — for collecting NEW events addressed to you, use poll_pending_actions. Shared NOTES (self-addressed rows, topic 'note:<key>') appear here collapsed to the latest value per key with to='self' — get_notes is the purpose-built reader.
get_catch_up
ChatGPTThe user's Catch-Up ("since I was gone") briefing: an AI summary of new emails since their last briefing, plus the new emails grouped by sender with unread counts. filter_type: 'all', 'personal' (Cleanbox only) or 'other' (promotional only). By default the window starts where the last briefing ended (capped); pass since_hours to force a specific look-back window. Recent briefings are cached server-side, so repeat calls are cheap.
get_connect_instructions
ChatGPTGiven an email address or domain, return the best way to connect it and the exact steps. Prefers one-click OAuth (oauth_available / oauth_provider) when we run a connector for that host — no password needed. Otherwise returns imap_suggestion with the host/port, the provider's help_url, and the app-password steps (app_password_note / instructions). Use this to walk a user through getting connected — especially IMAP users who need an app-specific password. A bare provider NAME is resolved to that provider where we hold one; when we do not, the result is recommended_method='needs_address' and you must ASK for the address rather than describing a provider. This returns GUIDANCE only; it never fetches or receives a password.
get_draft
ChatGPTGet a draft's full content (to, cc, bcc, subject, body).
get_email
ChatGPTRead a single email in full: subject, sender, recipients, date, the complete message text, attachments list, and (optionally) actionable links found in it (pay, log in, book, track…). Accepts ids from search_emails, get_feed AND deep_search_emails — provider-history ids (the 'gmail:<id>:<id>' form) are fetched live from the mail provider.
get_emails
ChatGPTRead SEVERAL emails in ONE call — always use this instead of looping get_email when you need the contents of more than one email (reviewing, summarising or triaging results from get_feed / search_emails / deep_search_emails). Up to 25 ids per call, in any mix of forms: local UUIDs, and provider-history refs ('gmail:…' / 'outlook:…' / 'imap:…'), which are fetched live from the mail provider. Each result carries the sender, date, direction (sent_by_user marks the user's OWN outbound mail — don't review it back to them as if it were incoming), folder and summary when classified, attachment names, and the body clipped to body_chars (default 2000; raise it — up to 10000 — when you need more text per email, or open the one email that matters with get_email for the full body and attachment CONTENTS). Per-id failures come back in errors without voiding the rest; if the response lists omitted_ids, those were NOT read — call again with them. DEAD IDS: error_details marks ids whose failure is SETTLED — error_code 'provider_ref_stale', retryable false — meaning that id no longer exists at the mail provider (deleted or moved, which changes the id); do not retry those, follow their recovery instead. One get_emails call replaces a whole get_email loop: batching is ~N times faster for the user.
get_feed
ChatGPTList the user's email feed (most recent first) without a search query. personal_or_ad='personal' is the Cleanbox (real correspondence); 'advertising' is promotional. email_type 'received' or 'sent'. account narrows to one connected mailbox (the address as shown in get_account_overview) — combine with personal_or_ad for that account's Cleanbox/Other. list_id shows one of the user's custom email lists (ids from list_email_lists). source narrows to a connected app's messages (e.g. 'slack' — see get_account_overview) or 'email' for mail only. sender filters by sender name or address fragment — combine freely, e.g. source='slack' + sender='<name>' + last_x_days=1 answers "what did <name> send me on Slack today?".
get_my_day
ChatGPTThe user's My Day view: today's tasks, events and commitments.
get_notes
ChatGPTRead the fleet's shared memory. No key: the latest value of EVERY key, newest first — call this at the start of a session to pick up where the previous session or another agent left off. key: that one note; history=true with a key lists its kept versions newest first (up to 20). limit: max keys (or, with key+history, max versions) to return (default 50, max 200). Any of the user's connections may read all notes — agents keep nothing from their principal. Empty result means nothing has been recorded yet; write with set_note.
get_priorities
ChatGPTThe user's priorities briefing — the SMALL set of things that genuinely need them right now, judged by Mailopoly's executive-assistant engine: bills ranked by consequence of inaction, replies they owe ranked by relationship cadence, and real upcoming events. Use this for "what needs me?", "anything important?", "am I on top of things?" — NOT for a general inbox listing (that's get_feed). It answers instantly from the stored briefing (age_minutes says how old it is); only an account that has none yet gets its first briefing built on the spot, which takes tens of seconds once. When the stored one has aged past its refresh window it comes back with stale=true and refreshing=true while a new one is built in the background — answer from it, and call again in a minute or two only if the user wants the rebuilt one. Do NOT pass refresh=true to get a fresher or better answer, or for "what needs me right now?": it never changes what this call returns. It only starts that background rebuild (refreshing=true) when the stored briefing is at least 15 minutes old, and is ignored when it is younger. Use it only when the user explicitly asks for the briefing to be rebuilt. timezone: IANA name, e.g. Europe/Paris; defaults to the user's profile timezone — used to judge what's due/overdue and to phrase dates. Each item carries a ref_id and options — apply the user's decision with resolve_priority; quiet an unwanted nudge with dismiss_nudge. nothing_pressing=true means exactly that: tell the user they're on top of things, don't invent urgency.
get_product_help
ChatGPTAnswer a HOW-DOES-MAILOPOLY-WORK question from the official product documentation — verified, never guessed. Call this whenever the user asks how to do something in Mailopoly or what a Mailopoly feature is or does: connecting WhatsApp / Slack / Instagram / Teams / TikTok, email signatures, Lists, My Day, Cleanbox, Provider Sync, deleting or restoring email, plans and what they include, the trial, Pro/Business, teams, the mobile apps, troubleshooting a connection — in any language. platform is where the user is working: 'web' (default, also Mac/Windows desktop), 'ios' or 'android'. Do NOT answer these from your own knowledge of email apps: Mailopoly's UI and rules are specific, and a plausible-sounding guess sends the user hunting for a control that does not exist. Relay answer as-is; if status is 'declined', say the documentation doesn't cover it and offer the support route in support. Works before the user has a trial.
get_widgets
ChatGPTThe user's My Data dashboard widgets (weather, news, stocks, custom) with their latest cached data. refresh=true re-fetches any widget whose rate limit allows it (e.g. weather every 10 min) before returning. include_catalog=true also lists the available widget types.
hide_emails
ChatGPTHide one or more emails from the user's feed (does not delete them). Optional reason, e.g. 'spam', 'not_interested', 'never_show_this_sender'.
identify_agent
ChatGPTRegister (or update) this session's agent identity: a short name like 'deploy-watcher' for what this session is, plus an optional description (max 300 chars) shown in the user's Agent Console and in the roster other agents see. Do it once at the start of a session, before send_agent_message / notify_user. The response carries an agent_token: keep it and pass it on later agent calls, since it identifies this session when several sessions share one Mailopoly connection, and the sender name on everything you send comes from it. Re-registering a name you created from the same connection without its token re-claims it and issues a fresh token; the old one stops working. To rename yourself, pass your agent_token with the new name. webhook_url (https, publicly reachable): when set, events addressed to this agent are delivered there as they happen, for self-hosted runners; pass an empty string to clear it. webhook_auth_header: the value your endpoint expects in its Authorization header, if it requires one; an empty string clears it. The response also lists the user's other active agents you can message, and the delivery details for your webhook. LIFECYCLE: an agent with no activity expires automatically (30 days for plain sessions, 7 days for webhook agents; webhook deliveries do not count as activity, only acting does); expires_after_hours (1-8760) overrides that per agent, short for throwaway sessions, long for durable runners. When a session finishes its job for good, call retire_agent. Identifying with a name the user pre-defined as a contact in their Agent Console claims that contact and collects any messages queued for it. platform: what runs you (e.g. 'Claude Code', 'ChatGPT', 'Gemini', 'cron script'), shown in the Agent Console; auto-detected from your connection when omitted.
list_drafts
ChatGPTList the user's email drafts (created in Mailopoly), newest first.
list_email_accounts
ChatGPTList the user's connected email accounts with their connection health and onboarding state. Use this to diagnose "I can't connect" / "my email isn't showing up" problems. Each account has a status: active, onboarding, pending, not_syncing (connected but never activated), reauthorization_required (needs reconnecting), or inactive (paused). Also returns mailbox_verdict and last_check_error when present. Connected messaging apps (Slack etc.) appear with kind='app'. Each mailbox may carry capabilities — what its stored permission grant lets Mailopoly do (can_read / can_send / can_organize, where organize = folders, moving emails, syncing clean-ups back). When a folder or send tool reports the connection lacks permission, check here and relay the capabilities summary verbatim — it explains the fix (reconnect and approve all permissions) in user-friendly words.
list_email_lists
ChatGPTThe user's custom email lists (smart folders): name, rules, unread and total counts. Browse a list's emails with get_feed(list_id=...); file/unfile specific emails with add_email_to_list / remove_email_from_list.
list_email_triggers
ChatGPTList the user's email triggers ("alert me when…" monitors): their conditions, runbooks, guardrail tiers, firing stats and how many fired events are still waiting to be collected via poll_pending_actions. A trigger that keeps failing to evaluate is retried with growing gaps (up to 2 hours) and shows a failing block until an evaluation succeeds.
list_events
ChatGPTList the user's calendar events extracted from their email (meetings, bookings, appointments). Dates are YYYY-MM-DD; defaults to upcoming.
list_invoices
ChatGPTList invoices and payments extracted from the user's email. invoice_or_payment: 'invoice' or 'payment'. search matches payee, description or category. time_range examples: this_month, last_month. Returns the most recent limit records (max 200) plus totals computed over the full matching set.
list_mailbox_folders
ChatGPTThe folders in the user's REAL mailbox, per connected account: Gmail labels, Outlook folders (with message counts), IMAP/iCloud folders. Omit account for every connected mailbox; pass account=<address> (as shown in list_email_accounts) for one. Each entry carries account_id — the unique handle to pass as account to the other folder tools when the same address is connected through two providers. Each folder says whether it is a user folder or a system one (INBOX, Sent, Trash, … — those can't be renamed/deleted). These are the provider's own folders — for the user's Mailopoly Lists (smart folders) use list_email_lists instead.
list_scheduled_emails
ChatGPTEmails the user has scheduled to send later (from any surface — the app, Poly or a connector) that have not gone out yet, soonest first. Each item has scheduled_send_id, send_at (UTC — convert to the user's timezone when you tell them), subject, recipients, from_address and any attachment names. Use the id with cancel_scheduled_email or reschedule_email. An empty list means nothing is waiting.
list_senders
ChatGPTEvery address that emails this user, and what Mailopoly does with mail from it — the data behind the web app's Senders screen. Use it for "who emails me most", "who have I unsubscribed from", "what happens to mail from X", or before changing a sender's settings, so you name the exact address. Each row carries the sender's address, the name shown for them, whether they are a person or a company, how much they send (30 days and all time), when they last wrote, their unsubscribe state, the lists they belong to, whether they are protected from bulk clean-ups, and their PLACEMENT: 'auto' (Mailopoly decides per email — the default), 'cleanbox' (always the personal folder), 'other' (always the promotional folder), or 'hidden' (never shown at all). Change any of that with set_sender_settings. query matches the sender's name or address. lens narrows the list to one group — 'all' (the default), 'cleanbox', 'other', 'hidden', 'unsubscribed', 'protected', 'rules' (senders with a rule) or 'lists' (senders in one of the user's lists). kind is 'person' or 'company'. sort is 'recent' (most recent mail first — the default), 'volume' (most mail first) or 'name'. limit caps at 100.
list_task_rules
ChatGPTList the user's task-suppression rules (rules that hide tasks from the task manager by sender, domain or subject). Returns rule ids usable with delete_task_rule.
list_tasks
ChatGPTList the user's tasks (aggregated from manual tasks, email actions, invoices, events, shipments and replies — the same data as the app's task manager / My Day). timeframe: relevant | today | tomorrow | this_week | this_month | overdue | last_7_days | next_30_days | all. task_type: all | action | event | invoice | shipment | reply.
list_whatsapp_templates
ChatGPTThe message templates on the user's WhatsApp Business Account, with each template's status, language, body text and required parameter counts. Only APPROVED templates can be sent (send_whatsapp_template); templates are created and approved in Meta's WhatsApp Manager, not here. account picks the WhatsApp number when several are connected (a phone number or its display name).
mark_email_read
ChatGPTMark an email as read (or unread with read=false).
mirror_mailbox_folders
ChatGPTTurn the user's REAL mailbox folders into Mailopoly Lists that keep themselves in step: one List per user folder (system folders like Inbox, Sent, Deleted Items, Junk and Archive are never mirrored), each filing the mail that is filed in that folder at the provider — now and as the user keeps filing there. This is the answer to "why can't I see my Outlook folders", "set up my folders here", "I file everything into folders and my Cleanbox is full of already-filed mail". preview=true only lists the folders (path, size, how many imported emails already carry it, whether a List exists) — show the user this and ask before applying. exclude_from_cleanbox=true (default, the filer's setting) keeps filed mail OUT of Cleanbox so Cleanbox shows the provider Inbox; false keeps filed mail in Cleanbox too (folders as labels). folders narrows to the given paths from the preview. Re-running is safe: existing mirrored Lists are updated, not duplicated. Outlook mailboxes for now. This never changes the user's mailbox.
move_emails_to_folder
ChatGPTMove emails into a folder in the user's REAL mailbox, acting directly on the provider account ("move these newsletters into my Reading folder"). Accepts up to 100 email ids per call (UUIDs or deep-search provider refs) — one call per batch, NEVER a loop of single calls. folder is matched by name per account. create_if_missing defaults to TRUE: when no folder with that name exists yet, one is CREATED for real in the user's mailbox (a new Gmail label / Outlook folder / IMAP folder) before the emails are moved into it — pass create_if_missing=false if the caller wants the move to fail instead when the named folder doesn't already exist. Gmail semantics: a move = add that label + remove from the Gmail inbox (the email also stays in All Mail) — the per-email detail says so; relay it when asked. Trash/Junk/Drafts/Sent are refused as destinations — deleting is a different action: use delete_emails (or hide_emails with reason='delete' on a tool list without delete_emails) instead. The result reports EVERY id as moved or not_moved (with reasons): relay partial outcomes honestly. TIME BUDGET: the call is capped server-side, so a slow mailbox returns confirmed results and identifies unresolved outcomes. A timed-out provider command may still complete: check the source and destination before retrying; do not split and repeat it. The email stays visible in Mailopoly — a provider move organises the mailbox, it never hides anything here. For filing into a Mailopoly List use add_email_to_list instead.
next_nudge
ChatGPTThe user asked "what else / show me the next one" on a nudge: rest the skipped item briefly (it can return later today) and surface the next eligible priority. This is a user-initiated pull, so it bypasses the stream's quiet window and daily cap — only call it when the user explicitly asks to see the next item. Returns the next nudge (with a pre-written suggested_reply when it's a reply), or none_eligible when the queue is empty.
notify_user
ChatGPTAlert the user — "ping me if anything goes wrong / when it's done". The alert IS a message: it lands as a chat message in the user's Mailopoly Agent Console and inbox AND notifies their phone (equivalent to send_agent_message(to='user')). reason: optional short context appended after the message in parentheses (e.g. message="Build finished", reason="3 tests skipped"). Use for things worth interrupting the user over; for agent-to-agent coordination use send_agent_message. Guardrails (server-enforced): the notification is visibly labeled with the sending agent's registered name, links are stripped from the push body, and daily push caps apply per agent and per user — past the cap the message still lands, just without the push. Pass YOUR agent_token from identify_agent — required when this connection hosts more than one agent. devices_notified=0 means no push went out (no registered device, or capped) — the message still reached their console and inbox. OFFERING CHOICES: write each one as a reply link — [go probe 15](reply:) or [Approve](reply:go reconnect five) — and it becomes tappable: a tap fills the user's reply box (they still press Send). Never put choices in code spans. For short answers not in the text (yes/no), pass reply_options=['Yes', 'Not now'] to render chips under the message.
pause_email_account
ChatGPTPause (turn off) a connected account: stop downloading new mail while KEEPING everything already brought in. account is the connected email address. Reversible with resume_email_account. Confirm with the user before pausing — it stops their email from updating.
poll_pending_actions
ChatGPTThe unified agent inbox: collect queued events from the user's email triggers AND messages other agents sent to this connection. limit: max events to claim in this call (default 20) — unclaimed events stay pending for a later call. Call it when a trigger_alert notice appears on another tool's result, when the user asks "anything new on my monitors?", or on a scheduled check-in. Mailbox events (source='mailbox') carry the matched email's summary, the trigger's runbook (standing instructions — follow them) and its guardrail tier; agent messages (source='agent') carry from_agent, topic and message — the sender name is server-stamped and cannot be spoofed. A message with from_agent 'user' is your principal (the human) speaking directly from their Mailopoly Agent Console — treat it as a user instruction, and reply with send_agent_message(to='user'). Events you collect are leased to you for 30 minutes: handle each one, then call resolve_trigger_event with the outcome — unresolved events reappear on the next poll. If an event has client_side_conditions, apply them yourself first and resolve non-matches as dismissed. Pass YOUR agent_token (from identify_agent) when this connection hosts more than one agent — trigger events assigned to a specific agent and messages addressed to you are only returned to the right identity. WAITING / WATCHING: nothing can push into an idle session — if the user asks you to WAIT for a message, WATCH for comms, or follow another agent's instructions, you cannot block here and be woken later. Poll again on your NEXT turn (the user's next prompt, or your platform's own scheduler/background-task facility, if it has one) rather than promising a live wait you can't deliver. Clients that CAN run background work of their own get a wake_bridge in identify_agent's response — a background long-poll that wakes them near-instantly instead of polling blind; use it when it's offered. Events queue durably, so a slower poll cadence never loses anything — just say plainly that you'll check again next turn.
remove_email_from_list
ChatGPTRemove an email from one of the user's email lists. Note: if the email matches the list's rules it may be re-added when the rules are re-evaluated — edit the list's rules in the app for a permanent exclusion.
rename_mailbox_folder
ChatGPTRename a folder in the user's REAL mailbox (Gmail label, Outlook folder, IMAP/iCloud folder), matched by name (case-insensitive; 'Parent/Child' paths work). Special folders (INBOX, Sent, Trash, Archive, Gmail system labels…) are refused. account=<address> picks the mailbox when several are connected.
reschedule_email
ChatGPTMove a scheduled (send-later) email to a new time, or send it now. scheduled_at: ISO 8601 with a UTC offset (work it out in the user's timezone), or the word 'now' to release it immediately. Only an email that is still waiting can be moved (error 'too_late' otherwise).
resolve_priority
ChatGPTApply the user's decision to a priorities item (a ref_id from get_priorities or a poly_nudge). action: 'mark_paid' (bill paid), 'mark_partial_paid' (needs paid_amount), 'snooze' (remind later — snooze_hours or snooze_days, default 14 days), 'complete' / 'handled' (done, e.g. a reply they say is dealt with), 'acknowledge', or 'not_relevant' ("never show me this again" — permanently suppresses the item from nudges, briefings and future reports; reversible only by un-hiding the task in the Mailopoly app, so confirm intent before using it). Pass the item's source object back VERBATIM and its headline as title. The change lands in the same task/invoice rows the app uses, so My Day, Tasks and future briefings all reflect it immediately. Item options that are views rather than dispositions are NOT valid values for action and are REJECTED if passed here — use the other tool named instead: 'view_email' -> get_email(source.email_id), 'open_reply' -> send_email with reply_to_email_id (offer the item's suggested_reply first), 'set_reminder' -> create_task with a reminder_date.
resolve_trigger_event
ChatGPTClose out a collected trigger event (id from poll_pending_actions) with a short outcome — what was done, or 'dismissed: <reason>'. This is the audit trail; every collected event should end here.
restore_emails
ChatGPTUndo hide_emails / delete_emails for one or more emails — the reverse of those tools. Omit action and each email is restored from whatever state it is in (deleted → undeleted, spam → not spam, hidden/archived → back in the feed); pass 'undelete', 'not_spam' or 'unhide' to be explicit. When Provider Sync mirrored the original action to the user's real mailbox (Bin / Junk / archive), the restore is mirrored back too — the result's provider_effect says so. Up to 100 ids per call. Every id is accounted for: restored, not_restored. A sender BLOCK made with hide_emails(reason='never_show_this_sender') is not lifted by this tool — the user removes it under Profile → Preferences in Mailopoly.
resume_email_account
ChatGPTTurn syncing back on for one of the user's connected email accounts that the user previously paused with pause_email_account. account is the paused account's email address. Call it only when the user asks to resume, un-pause or turn that account back on. The call changes one setting in the user's own Mailopoly account: it marks the account active so that Mailopoly's sync service resumes fetching new mail on its normal schedule. Everything already imported is unchanged, nothing is deleted or sent, and no message is fetched inside this call. The reply confirms the account's new status. If the reply has blocked=true the account cannot resume on the user's current plan: relay message and plan_info_url and do not call again until the user has changed their plan or removed another account. Calling it on an account that is already active changes nothing and returns success. It does not add a new account (that is start_email_connection) and does not fix missing mail on an active account (that is check_email_sync).
retire_agent
ChatGPTRemove a registered agent by name — use when a session's job is done, or to clean up stale entries the user points out. Any of the user's connections may retire any of their agents (re-registering the name revives it fresh). The agent's queued events are expired. Idle agents also fade out automatically, so this is for immediate cleanup, not a required sign-off.
save_draft
ChatGPTCreate an email draft (or update an existing one by draft_id). The draft appears in the user's Mailopoly drafts and can later be sent with send_email (requires the 'send' scope). to/cc/bcc are email addresses, comma-separated for multiple recipients. For a reply, pass reply_to_email_id (the original's email_id) — to is then optional and the reply is routed automatically when sent, including replies to connected-app messages (Slack etc.), which have no email address. body is plain text or HTML.
search_emails
ChatGPTSearch the user's emails by free text (subjects, senders, bodies, attachment text). Optional filters: sender (name or address fragment), start_date/end_date (YYYY-MM-DD), last_x_days, email_type ('received' or 'sent'), personal_or_ad ('personal' or 'advertising'). Returns matching emails with ids for use in get_email / get_action_links. Covers Mailopoly's indexed history only — for older mail beyond the indexed window (the response's indexed_history_start), use deep_search_emails.
send_agent_message
ChatGPTA decision ask to the user (needs_reply) must carry tappable answers — reply_options or [go x](reply:) links; backticks are copy chips; else it is refused: reply_options_required. Send a message to another of the user's agents through Mailopoly — the agents' switchboard: works across machines, codebases and clients, because every agent talks to the same Mailopoly account. to: a registered agent name, 'all' to broadcast to every other agent, or 'user' to message your principal (the human) directly — it lands as an unread chat message in their Mailopoly Agent Console AND notifies their phone (server-labeled with your name, links stripped, daily caps; past the cap the message still lands, just silently — no separate ping_user needed). needs_reply (to='user' only): set true when you are asking the user for an answer or a decision — it files the message into their reply queue (My Day) until they respond; leave false for status reports and FYIs so their queue stays honest. FORMAT for to='user': the body renders as Markdown in the user's chat (web, phone, Agent Console) — write it like a good assistant reply, not a log line. Lead with the outcome or the decision you need in one line; then short paragraphs separated by blank lines; '- ' bullets for items, fixes and numbers; a markdown table for anything tabular (accounts x status, before/after); bold the ask ("Reply purge or leave"). Never send one unbroken block — a paragraph over ~3 sentences is unreadable on a phone. Deep detail belongs in a handoff doc you name, not in the message. OFFERING THE USER CHOICES: when you ask the user to pick or approve something, make each choice tappable by writing it as a reply link — [go probe 15](reply:) (the text IS the reply) or [Approve](reply:go reconnect five) (label differs from the reply). Tapping fills the user's reply box with that text; they still press Send. Do NOT put choices in code spans — those are not tappable. For short answers that are not in your text (a yes/no ask) pass reply_options=['Yes, go ahead', 'Not now'] — they render as chips under the message. Reply links only work in messages to the user; to other agents they arrive as their plain label. Bodies to other agents are read by a program, not a person: structure those however the recipient parses best. Delivery to agents is durable: recipients get it on their next poll_pending_actions, see an ambient notice on any Mailopoly call, and if they registered a webhook it is POSTed to them immediately. Use topic to label threads of work (e.g. 'deploy-status'). ping_user=true (agent recipients only): also deliver a copy of the message to the user — it lands in their console and inbox and notifies their phone, exactly like to='user'; never a bare notification. Pass YOUR agent_token from identify_agent — required when this connection hosts more than one agent; the sender name is stamped from it and cannot be spoofed. If you EXPECT A REPLY, don't wait passively: check poll_pending_actions again on your next turn until it arrives — see that tool's guidance on being woken sooner if your platform allows it. Addressing YOURSELF (to=<your own registered name>) delivers nothing: it stores the body as a shared NOTE under topic 'note:<key>' (latest wins) — the same thing set_note does. STRUCTURE (optional): summary + sections — see the parameter descriptions. The user may set your reply mode (detailed | brief) in the Agent Console; identify_agent and poll_pending_actions return reply_format + format_guidance; a mailopoly:format notice arrives when it changes. In brief mode pass summary every time (the server derives one from your first sentence if you do not, and tells you in format_hint).
send_email
ChatGPTSend an email as the user through their connected account (Gmail, Outlook, @mly.life or IMAP), or reply to any message by passing reply_to_email_id (an email_id from search/feed/get_email). Replies: with reply_to_email_id set, to/subject are optional — the recipient and threading come from the original. If the original is a message from a connected app (source != 'email', e.g. Slack), the reply is delivered back through that app as the user (same thread/DM) — do NOT pass an email address for app messages; their senders have none. If draft_id is given, the draft's content fills any field not explicitly provided. from_account selects which connected address to send from (defaults to the account the original arrived on for replies, else the primary). content_type: 'HTML' or 'TEXT'. Subscription limits apply.
send_whatsapp_template
ChatGPTStart a WhatsApp conversation with someone who hasn't messaged the business, by sending ONE Meta-approved message template to ONE phone number — the only way WhatsApp allows a business-initiated message outside the 24-hour reply window. to is the full international number (+447700900123). template_name/language identify an APPROVED template from list_whatsapp_templates; body_params fills its {{1}}..{{n}} placeholders in order; header_param fills a text-header placeholder. The sent message is recorded in Mailopoly, so the person's reply threads into a normal conversation (and opens the free-form window). account picks which connected WhatsApp Business number to send from when several are connected (a phone number or its display name, as returned by list_whatsapp_templates); omit it when only one is connected. Meta bills template conversations per its category pricing. One recipient per call — this is not a broadcast tool.
set_daily_briefing
ChatGPTTurn Mailopoly's daily briefing on/off, or subscribe the user to one of Mailopoly's scheduled REPORT EMAILS and set its schedule. Without report: the MASTER switch — enabled=false stops the in-chat daily briefing AND EVERY report email; enabled=true restores them. Bare call = "stop everything" only (a single nudge: dismiss_nudge). With report: ONE emailed report. START: enabled=true + report. STOP: enabled=false WITH that report — set_daily_briefing(report='digest', enabled=false) for "stop the digest" / "detén el resumen" / "pare o resumo". NEVER answer "stop <one report>" with the bare call: it silences every report the user has. Reports: 'my_day' (today's tasks, events and bills), 'priorities' (the short list of what needs the user), 'digest' (catch-up of what's come in, over the folder they pick), 'second_digest' (a second digest, own folder and hour — e.g. Cleanbox at 8, Other at 18). frequency: 'daily' (default) | 'weekdays' | 'weekly' (+ weekly_day 0=Monday..6=Sunday, default Monday). hour: 0-23 in the user's OWN local time (profile timezone; set_timezone first if unset). Pass hour ONLY when the user names a time — omitted, they keep their current hour (7 for the morning reports, 17 for a digest). my_day and priorities SHARE one morning hour, so hour on either MOVES the other one too; say so. Whole hours only — no minutes: round 7:30 to the nearest hour and tell the user. folder ('cleanbox' | 'other' | 'all'): digests only. Omitted settings keep their values, but enabled is written every time — pass enabled=true when you are only changing a schedule. Delivery: to the account's login address (or the Mailopoly inbox if no external mailbox) — there is no recipient parameter; if asked to email a report to an assistant or another address, say Mailopoly can only email the account holder. A report covers its FOLDER across ALL connected mailboxes — no per-account report (get_feed filters by account; a scheduled report cannot). Sent from the chosen hour onward — usually within minutes, up to 4 hours later — only on days with something to report, and only while the account has an active plan or trial, a connected mailbox, and has used Mailopoly in the last 21 days; the result lists whatever blocks delivery under not_sending_because. Enabling a report switches the master switch back on. Current settings: get_account_overview → report_emails. Nothing is sent by this call and there is no on-demand report email: for "send it now" show get_catch_up in the chat instead; re-calling with the same settings changes nothing.
set_language
ChatGPTSet the user's preferred language for the Mailopoly website and the notification emails Mailopoly sends them — a BCP-47 code like 'es', 'fr', 'de', 'pt', 'ja', 'ar', 'zh', 'ru'. Call this ONCE, early, as soon as you can tell from the conversation which language the user actually speaks/writes (e.g. they message you in German → call set_language('de'); their first request is in Arabic → set_language('ar')). This does NOT change how you reply in this chat — it makes their Mailopoly website and notification emails render natively, which they otherwise can't tell you because they never see English here. The scheduled report emails (My Day, priorities, digests) are written in English for now regardless of this setting — say so if asked. If the user clearly uses English, just skip it (English is the default). Takes effect immediately and never overrides a language the user picked themselves in Mailopoly's settings.
set_note
ChatGPTWrite the fleet's shared memory: one value per key, latest wins (the last 20 versions are kept), readable by every agent on this user's account and by Poly. Use it for DURABLE STATE, not conversation: the current status of a job, what you are waiting on, decisions and preferences the user has given, a handoff line for whoever picks up next — so a new session, a second agent or the user's phone can continue without re-deriving it. Never store email content, credentials, or anything the message transcript already holds. Requires an identity (identify_agent); pass your agent_token when this connection hosts more than one agent. Older clients get the same effect with send_agent_message(to=<your own name>, topic='note:<key>').
set_sender_display_name
ChatGPTSet the From name recipients see on email sent from one of the user's connected accounts (e.g. "Martin+Zavagno GmbH" instead of a bare address). account is the connected email address (from list_email_accounts). Pass display_name empty (or omit it) to CLEAR the name — recipients then see the email address itself. Use this when the user asks to change the name their email shows as / sends as, or complains their outgoing mail shows the wrong or no name. The same setting as the web app's compose-screen "Sender display name" dialog; takes effect on the next email sent. This is the user's OWN outgoing name only — to change what a CONTACT of theirs is called inside Mailopoly, use set_sender_settings(sender=..., display_name=...).
set_sender_settings
ChatGPTChange what Mailopoly does with ONE sender, and keep their contact card: rename them for this user, protect them from bulk clean-ups, choose where their mail goes, add notes, and record contact details (phone, company, job title, addresses, birthday, websites, custom facts, dated interactions) the user tells you about them. This is the Senders screen's settings, reachable by name or address; list_senders shows the current state of every sender. Pass only the things you are changing — anything omitted is left as it is, and at least one of display_name, protected or placement is required. Placement in words: 'auto' lets Mailopoly sort each email as usual, 'cleanbox' always files them as personal correspondence, 'other' always files them as promotional, and 'hidden' stops showing that sender at all. Renaming a sender changes only what THIS user sees, not the name on the emails themselves and not anything the sender sees. Mailopoly's own addresses, and the user's own connected addresses, cannot be sent to 'other' or hidden — those calls are refused.
set_timezone
ChatGPTUpdate the user's timezone. timezone must be an IANA name like 'America/New_York', 'Europe/London' or 'Asia/Kolkata' — NOT an abbreviation (EST) or a UTC offset. Call this whenever the user says they've moved or are travelling, gives their location/timezone, or tells you the times you're showing are off by a fixed number of hours: the server localizes every timestamp it returns to this zone, so fixing it here corrects all of them. The change takes effect immediately.
snooze_email
ChatGPTSnooze an email — it leaves the feed and comes back when the time passes (same shape as snooze_task). Give EITHER snooze_until (ISO 8601 local time, e.g. '2026-09-12T09:00' — interpreted in timezone, an IANA name defaulting to the user's own) OR a relative duration (duration_value + duration_unit: 'minutes', 'hours', 'days' or 'weeks', e.g. 3 + 'days'). email_id is an id from search/feed/get_email. The result carries snoozed_until (UTC).
snooze_reconnect_reminder
ChatGPTWhen the user asks NOT to be reminded about a lost mailbox connection ("don't remind me", "stop mentioning this", "I'll deal with it later"), call this to stop the connection_alert appearing for days days (their choice; default 7, max 365 — rounded to the nearest whole day). account limits it to one address (from the alert); omit to snooze every currently-disconnected account. The mail still won't sync while disconnected — this only silences the reminder. days=0 turns reminders back on ("remind me again"). A NEW account that loses its connection later still alerts. Confirm the snooze back to the user in one short sentence.
snooze_task
ChatGPTSnooze a task. Either pass snooze_until (ISO datetime, in the given timezone — defaults to the user's own timezone) or a relative duration (duration_value + duration_unit, e.g. 3 + 'days', 2 + 'hours', 1 + 'weeks').
start_email_account_sync
ChatGPTStart (or retry) syncing a connected account that isn't syncing yet, e.g. one with status 'not_syncing' (connected during signup but never activated) or 'pending'. account is the connected email address. This pulls in the account's mail, tasks, bills and events. An account whose status is already active or onboarding is left alone: the call returns success with already_onboarded / already_onboarding and starts nothing; do not call it again for that account (a missed-mail pull is check_email_sync(force=true)). CONFIRMATION: the first call may return requires_confirmation=true with question and next_call when activating this account changes what the user's plan covers. Ask the user that one question and wait for their answer. If they say yes, call this tool again exactly as next_call says (same account, confirm_billing=true); the account does not start syncing until that second call, so do not stop after asking. If they decline, leave it. Only pass confirm_billing=true after the user said yes in this conversation. BLOCKED: if the reply has blocked=true (reason 'seat_limit'), the account cannot start on the user's current plan; there is no next_call and confirm_billing does not override it. Relay the message and the plan_info_url it carries, and do not call again for that account until the user has changed their plan or removed another account. QUEUED: if the reply has queued=true, the account is connected and waiting its turn; say message as it stands and stop, the user will be emailed when it is ready.
start_email_connection
ChatGPTBegin connecting an email account (or reconnecting one whose access expired) by returning a Mailopoly link for the user to open. Pass email_or_provider (the address or provider they want to add) for a NEW connection, or account (an existing connected address) to RECONNECT one flagged reauthorization_required. The link opens Mailopoly's own page, where the user completes the connection themselves; nothing is entered in this chat. For IMAP providers, call get_connect_instructions first so you can tell the user what their provider needs, then give them this link. Relay the returned url to the user. Pass the ADDRESS in email_or_provider whenever the user named one (not just the provider): the address is what lets a browser that opens without a Mailopoly session be attached to THIS account instead of creating a new one.
unsubscribe_sender
ChatGPTUnsubscribe the user from ONE sender: Mailopoly requests removal through the sender's own unsubscribe mechanism (the List-Unsubscribe header or link in their emails), keeps retrying if it is not honoured, and files that sender's mail out of the inbox meanwhile. Name the sender by sender (their email address, e.g. from an email's from) OR by email_id (an email from them — the sender is taken from it); one sender per call. Confirm with the user first and never unsubscribe from a sender they did not name. The result says whether the request was queued, was already in progress, or was skipped (no visible mail from that sender). Undo with action='cancel': stops the request and the sender block so future mail arrives normally; restore_history=true with 'cancel' also moves their already-filtered mail back into the Other folder. Personal correspondence has no unsubscribe mechanism — for a person the user wants to stop hearing from use hide_emails(reason='never_show_this_sender') instead. WORDING: the result carries provider_unsubscribed, unsubscribe_method, hidden_count, unsubscribe_link and user_facing_summary. provider_unsubscribed is false while the request is only queued — never tell the user they are "unsubscribed" unless it is true; say the request was sent and their mail is filed out of the inbox meanwhile, and give unsubscribe_link when present.
update_email_list
ChatGPTUpdate one of the user's Lists — their Mailopoly smart folders (id from list_email_lists) — IN PLACE: rename it, hide/un-hide its emails from the main feed (exclude_from_cleanbox), set notifications (notify_mode: default|always|never), or change what it catches with add_rule / remove_rule — ONE rule each, {type, value, block: 'any' (catch) | 'none' (keep out)}, the same rule types as its match_rules; its mail is re-filed. Never delete and re-create a list to edit it. The result carries changed: false means NOTHING was written — say so with its reason, never as an update; when true, report its changes (they include how many emails left the Cleanbox when a list starts hiding its mail).
verify_email_account
ChatGPTRun a live check on one connected account and explain what's wrong, if anything. account is the connected email address (from list_email_accounts). Returns a status: ok, wrong_mailbox (signed in but the real mail is hosted elsewhere — see imap_suggestion), provider_mismatch, empty_mailbox, token_expired (needs reconnecting via start_email_connection), or wrong_provider. Use this when a user says their email isn't syncing to tell them precisely why and what to do next.
about_mailopoly
Claudeadd_email_to_list
Claudecheck_email_sync
Claudecomplete_task
Claudecreate_email_list
Claudecreate_task
Claudecreate_task_rule
Claudedeep_search_emails
Claudedelete_task_rule
Claudeget_account_overview
Claudeget_action_links
Claudeget_catch_up
Claudeget_connect_instructions
Claudeget_draft
Claudeget_email
Claudeget_feed
Claudeget_my_day
Claudeget_widgets
Claudehide_emails
Claudelist_drafts
Claudelist_email_accounts
Claudelist_email_lists
Claudelist_events
Claudelist_invoices
Claudelist_task_rules
Claudelist_tasks
Claudemark_email_read
Claudepause_email_account
Clauderemove_email_from_list
Clauderesume_email_account
Claudesave_draft
Claudesearch_emails
Claudesend_email
Claudeset_language
Claudeset_timezone
Claudesnooze_task
Claudestart_email_account_sync
Claudestart_email_connection
Claudeverify_email_account
Claude
