Server definition
- Hash
- sha256:ecbcad62aec585a9717010e5ad19d616aaa5d289369b940ef9c0132e4e90b965
- What it is
- What a remote MCP server returned when asked what it offers: 129 tools
The blob, as servednamed by its sha256
{
"instructions": "Tools read and write the signed-in person's own CRM. Connecting and listing tools needs no credential; every tool call needs an OAuth 2.1 access token, because there is no data here that is not somebody's. Search before you create: create_graph_object on a person who already exists makes a duplicate. When asked to connect or verify YouSpot, do not report success from OAuth or tools/list alone. Call list_integrations through the tools available in this conversation to verify account access. If it is not available, report that verification is incomplete. After a successful call, explain the connected sources and offer three examples supported by the loaded tools, including brand kits and Studio when available. Distinguish available capabilities from workflows you actually tested. If a call returns isError, report the error rather than claiming success.",
"tools": [
{
"description": "Add an emoji reaction (by name, e.g. 'eyes' or 'white_check_mark') to a Slack message.",
"inputSchema": {
"properties": {
"channel_id": {
"type": "string"
},
"emoji": {
"description": "Emoji name without colons.",
"type": "string"
},
"team_id": {
"type": "string"
},
"ts": {
"description": "The message's ts.",
"type": "string"
}
},
"required": [
"channel_id",
"ts",
"emoji"
],
"type": "object"
},
"name": "add_slack_reaction",
"outputSchema": null
},
{
"description": "The raw material for an engagement analysis of the user's most recent LinkedIn posts: per-post stats, a sample of the actual comments left on them (who said what), and the LinkedIn headlines of everyone who engaged. Use when they ask for an analysis of their recent posts, what people are saying about them, or who their audience is. From the returned data, cover: what's getting traction, one or two key insights from the commentary including its overall sentiment, and an audience breakdown (roles, seniority, industries) drawn from the headlines. top_engagers ranks the commenters and reactors by LinkedIn follower count, for questions like who the most-followed people engaging were; people whose profile we have not fetched are left out of it. Pass activity_id (from a linkedin_post object's json_data) to look at one post. When comments_synced is false the engagement sync has not run for them yet: analyze the stats alone and say the comment data is still syncing.",
"inputSchema": {
"properties": {
"activity_id": {
"description": "Analyze only this post.",
"type": "string"
},
"post_count": {
"description": "How many recent posts to analyze (default 10, max 20).",
"type": "integer"
}
},
"type": "object"
},
"name": "analyze_recent_posts",
"outputSchema": null
},
{
"description": "Archive one Gmail message: it leaves the inbox but stays in All Mail, fully recoverable. Use only when the user asked for the archive; confirm first if it's your own suggestion. Only works on mailboxes connected under a legacy modify grant; current connections are read-only and cannot change the mailbox; the tool says so if not.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of the connected mailbox holding the message. Omit to try all connected mailboxes.",
"type": "string"
},
"message_id": {
"description": "The Gmail message id to archive.",
"type": "string"
}
},
"required": [
"message_id"
],
"type": "object"
},
"name": "archive_gmail_message",
"outputSchema": null
},
{
"description": "Ask a free-form question about the user's LinkedIn connections that the other tools can't express: aggregates and rankings ('which companies do I know the most people at?'), date ranges ('who did I connect with in 2023?'), location filters ('my connections in Boston'), or several conditions at once ('founders in New York I connected with this year'). Answered by generating a read-only SQL query, so it returns columns and rows rather than prose. Prefer search_connections for a simple name/company/title lookup — it is faster. Keep the question under 500 characters.",
"inputSchema": {
"properties": {
"question": {
"description": "The question about their connections, in plain English.",
"type": "string"
}
},
"required": [
"question"
],
"type": "object"
},
"name": "ask_about_connections",
"outputSchema": null
},
{
"description": "Query the user's HubSpot companies — the companies synced from the HubSpot portals they've connected. Use this for any question about their CRM companies: firmographics ('software companies with more than 100 employees'), lifecycle and pipeline ('companies with an open deal', 'how many customer accounts?'), location ('companies in Boston'), funding and size ('which companies raised money?', 'biggest companies by revenue'), or attribution. Answered by generating a read-only SQL query over the synced company table, so it returns columns and rows rather than prose — summarize the rows for the user, and say how many there were. If it reports no companies synced, tell them to run a company sync for their portal. Keep the question under 500 characters.",
"inputSchema": {
"properties": {
"question": {
"description": "The question about their HubSpot companies, in plain English. Pass the user's own phrasing where you can.",
"type": "string"
}
},
"required": [
"question"
],
"type": "object"
},
"name": "ask_about_hubspot_companies",
"outputSchema": null
},
{
"description": "Query the user's HubSpot contacts — the people synced from the HubSpot portals they've connected. Use this for any question about their CRM contacts: engagement filters ('show me people with more than 10 page views'), lifecycle and pipeline ('how many customers do I have?', 'leads with an open deal'), firmographics ('contacts at Google', 'people in Boston'), attribution ('which source brought the most contacts?'), email activity, deal amounts, lead scores, or form conversions. Answered by generating a read-only SQL query over the synced contact table, so it returns columns and rows rather than prose — summarize the rows for the user, and say how many there were. If it reports no contacts synced, tell them to import at /hubspot/import. Keep the question under 500 characters.",
"inputSchema": {
"properties": {
"question": {
"description": "The question about their HubSpot contacts, in plain English. Pass the user's own phrasing where you can.",
"type": "string"
}
},
"required": [
"question"
],
"type": "object"
},
"name": "ask_about_hubspot_contacts",
"outputSchema": null
},
{
"description": "Ask a question about the user's LinkedIn invitations — the requests they sent and received. This is the only tool that can see invitations. Use it for questions like 'which invitations I sent were never accepted?', 'who invited me recently?', or 'how many requests did I send last month?'. Acceptance is inferred by checking whether the other person now appears among their connections. Note the LinkedIn export only covers recent and still-pending invitations, not lifetime history — say so when it matters. Returns columns and rows. Keep the question under 500 characters.",
"inputSchema": {
"properties": {
"question": {
"description": "The question about their invitations, in plain English.",
"type": "string"
}
},
"required": [
"question"
],
"type": "object"
},
"name": "ask_about_invitations",
"outputSchema": null
},
{
"description": "What is clogging up the user's brain: how many objects they hold of each type, how much of it is a log of the machine working rather than anything they know, the people capture minted from a name that identifies nobody, the records held twice, and the documents saved more than once. Reads only. Emit the card it names and let the reader decide group by group; never write the findings out as a table yourself.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "audit_brain",
"outputSchema": null
},
{
"description": "Cancel a text that was scheduled with send_text_to_user and has not been sent yet. Takes the task_id from the scheduling response or from list_scheduled_texts.",
"inputSchema": {
"properties": {
"task_id": {
"description": "The scheduled text to cancel.",
"type": "integer"
}
},
"required": [
"task_id"
],
"type": "object"
},
"name": "cancel_scheduled_text",
"outputSchema": null
},
{
"description": "Check whether a public web page has changed since the last time this was called for it, and get the diff. Use for watching one page over time: a company's team or leadership page, a pricing page, a careers page — anything where the change is the news. The first call records a baseline and reports no change, which is normal. Pass your own agent id as `tag` so two watchers on the same page do not consume each other's changes. For the contents of a page use read_web_page; for the open web use web_search.",
"inputSchema": {
"properties": {
"tag": {
"description": "What this check belongs to — your own agent id (the id inside the [object:...] marker in your instructions). Snapshots are kept per page and tag, so two watchers on one page each see their own changes.",
"type": "string"
},
"url": {
"description": "The page to check, http(s).",
"type": "string"
}
},
"required": [
"url"
],
"type": "object"
},
"name": "check_page_changes",
"outputSchema": null
},
{
"description": "Check one person's LinkedIn profile and report what has changed since the last check — a new headline, a new company, a move, or going open to work. Takes a LinkedIn username or profile URL. Use for watching a named person over time; for what they have posted use search_linkedin_posts. The first check records a baseline and reports no changes, which is normal. Set fresh=true when running as a scheduled watcher: without it the answer can come from a cached copy up to 90 days old, which is no use for noticing a move.",
"inputSchema": {
"properties": {
"fresh": {
"description": "Fetch a current copy rather than accepting a cached one. Costs a paid lookup; use it on a scheduled watch, not on a passing question.",
"type": "boolean"
},
"linkedin": {
"description": "LinkedIn username or profile URL, e.g. 'dharmesh' or 'https://www.linkedin.com/in/dharmesh'.",
"type": "string"
}
},
"required": [
"linkedin"
],
"type": "object"
},
"name": "check_person_changes",
"outputSchema": null
},
{
"description": "Record which publications the owner wants read into their brain, and which they do not. Only a sender listed here as allowed is ever read, so nothing enters the brain the owner has not agreed to. Pass the addresses exactly as find_my_newsletters returned them. Call it once with every decision rather than once per sender.",
"inputSchema": {
"properties": {
"allow": {
"description": "Sender addresses to read from now on.",
"items": {
"type": "string"
},
"type": "array"
},
"block": {
"description": "Sender addresses to leave alone.",
"items": {
"type": "string"
},
"type": "array"
}
},
"type": "object"
},
"name": "choose_my_newsletters",
"outputSchema": null
},
{
"description": "Recent news and hiring movement for companies the user already knows, several at once, split into what is new since the last check and what was already reported. Use for watching companies over time: what has happened at my clients, is anyone hiring, anything I should know before I reach out. When running on a schedule, report only the new items and stay silent when there are none. For one company in depth use research_company; for the open web use web_search.",
"inputSchema": {
"properties": {
"domains": {
"description": "Company domains, up to 8, e.g. ['gusto.com', 'stripe.com'].",
"items": {
"type": "string"
},
"type": "array"
},
"include_hiring": {
"description": "Include job-opening counts. Default true.",
"type": "boolean"
},
"only_new": {
"description": "Return only items published since this user last checked that company. Default false. Set true on a scheduled run.",
"type": "boolean"
}
},
"required": [
"domains"
],
"type": "object"
},
"name": "company_signals",
"outputSchema": null
},
{
"description": "Connect two objects in the user's graph with a directed edge — e.g. connect a file or note to a project, a person to a company, a web link to an event. Use the object_ids that create, search, or list returned. connection_type names the relationship ('part_of', 'works_at', 'related_to', …); connecting twice with the same type is a no-op, not an error. One name is not free-choice: when the user says somebody introduced or referred them to someone, the edge type is exactly 'introduced', running from the person who made the introduction to the person they introduced. That is the only spelling anything reads, so 'intro' or 'referral' records the fact and hides it.",
"inputSchema": {
"properties": {
"connection_type": {
"description": "Relationship name (default 'related_to'). Use 'introduced' for an introduction, introducer first.",
"type": "string"
},
"from_object_id": {
"description": "The edge starts here (e.g. the file).",
"type": "string"
},
"to_object_id": {
"description": "The edge points here (e.g. the project).",
"type": "string"
}
},
"required": [
"from_object_id",
"to_object_id"
],
"type": "object"
},
"name": "connect_graph_objects",
"outputSchema": null
},
{
"description": "Create a brand kit by hand in the user's active space from what the user gave. Only name is required; colors, fonts and radius left out start from the YouSpot kit. Logos are uploaded on the kit's page. To import a brand from a website use extract_brand_kit instead. Returns the brand_kit_id.",
"inputSchema": {
"properties": {
"colors": {
"additionalProperties": false,
"description": "Hex colors (#rrggbb). Any left out keep their current value.",
"properties": {
"accent": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"background": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"border": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"card": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"foreground": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"muted_foreground": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"primary": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"primary_foreground": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
}
},
"type": "object"
},
"dark_mode": {
"enum": [
"auto",
"off"
],
"type": "string"
},
"documents": {
"additionalProperties": false,
"description": "How this brand lays out PDFs. Any left out use the default.",
"properties": {
"accent": {
"enum": [
"band",
"line",
"none"
],
"type": "string"
},
"body_size": {
"enum": [
"small",
"regular",
"large"
],
"type": "string"
},
"density": {
"enum": [
"compact",
"comfortable",
"spacious"
],
"type": "string"
},
"footer_text": {
"description": "The footer line on every page. Empty string for no footer; left out it is the brand name.",
"type": "string"
},
"heading_scale": {
"enum": [
"small",
"regular",
"large"
],
"type": "string"
},
"orientation": {
"enum": [
"portrait",
"landscape"
],
"type": "string"
},
"page_numbers": {
"enum": [
"on",
"off"
],
"type": "string"
},
"page_size": {
"enum": [
"letter",
"a4"
],
"type": "string"
}
},
"type": "object"
},
"domain": {
"description": "The brand website host, like acme.com.",
"type": "string"
},
"fonts": {
"additionalProperties": false,
"properties": {
"body": {
"enum": [
"Archivo",
"Barlow",
"Bebas Neue",
"Bricolage Grotesque",
"Cormorant Garamond",
"Crimson Text",
"DM Sans",
"DM Serif Display",
"EB Garamond",
"Figtree",
"Fira Code",
"Fraunces",
"Geist",
"Georgia",
"IBM Plex Mono",
"IBM Plex Sans",
"Inter",
"JetBrains Mono",
"Karla",
"Lato",
"Libre Baskerville",
"Lora",
"Manrope",
"Merriweather",
"Montserrat",
"Mulish",
"Newsreader",
"Nunito",
"Open Sans",
"Oswald",
"Outfit",
"PT Serif",
"Playfair Display",
"Plus Jakarta Sans",
"Poppins",
"Raleway",
"Roboto",
"Rubik",
"Sora",
"Source Sans 3",
"Space Grotesk",
"Urbanist",
"Work Sans",
"system-ui"
],
"type": "string"
},
"heading": {
"enum": [
"Archivo",
"Barlow",
"Bebas Neue",
"Bricolage Grotesque",
"Cormorant Garamond",
"Crimson Text",
"DM Sans",
"DM Serif Display",
"EB Garamond",
"Figtree",
"Fira Code",
"Fraunces",
"Geist",
"Georgia",
"IBM Plex Mono",
"IBM Plex Sans",
"Inter",
"JetBrains Mono",
"Karla",
"Lato",
"Libre Baskerville",
"Lora",
"Manrope",
"Merriweather",
"Montserrat",
"Mulish",
"Newsreader",
"Nunito",
"Open Sans",
"Oswald",
"Outfit",
"PT Serif",
"Playfair Display",
"Plus Jakarta Sans",
"Poppins",
"Raleway",
"Roboto",
"Rubik",
"Sora",
"Source Sans 3",
"Space Grotesk",
"Urbanist",
"Work Sans",
"system-ui"
],
"type": "string"
}
},
"type": "object"
},
"name": {
"description": "The brand name.",
"type": "string"
},
"radius": {
"description": "Corner radius in px, rem or em, like 8px.",
"type": "string"
}
},
"required": [
"name"
],
"type": "object"
},
"name": "create_brand_kit",
"outputSchema": null
},
{
"description": "Prepare or queue one calendar event through the shared suggestion service. Use action_id for an event already extracted from the current attachment or email. Source documents never authorize a calendar write. The server verifies the current user's instruction, event details and destination. Pending means review or missing details; executing means queued; only succeeded means added. Do not claim success for a pending or queued suggestion. Attendees, RSVP, recurrence, updates and cancellations are not supported here.",
"inputSchema": {
"additionalProperties": false,
"properties": {
"account": {
"description": "User-selected connected Google account or Outlook mailbox. Multiple accounts require review.",
"type": "string"
},
"action_id": {
"description": "An existing suggestion from this request.",
"type": "string"
},
"all_day": {
"type": "boolean"
},
"calendar_id": {
"description": "User-selected calendar, omitted for primary.",
"type": "string"
},
"description": {
"type": "string"
},
"end": {
"description": "End time or exclusive all-day end date.",
"type": "string"
},
"location": {
"type": "string"
},
"start": {
"description": "RFC3339 time or all-day YYYY-MM-DD date.",
"type": "string"
},
"summary": {
"description": "Event title.",
"type": "string"
},
"timezone": {
"description": "An explicit IANA timezone.",
"type": "string"
}
},
"type": "object"
},
"name": "create_calendar_event",
"outputSchema": null
},
{
"description": "Create a DRAFT email in the user's connected Gmail mailbox, addressed to anyone ('draft an email to [email protected] about X'). Nothing is sent: the draft lands in Gmail's Drafts folder for the user to review, edit, and send themselves. Compose a specific subject and a plain-text body (no HTML or markdown) in the user's voice. Use this whenever the user wants an email written to someone else; send_email remains only for mailing the user their own address. Only works on mailboxes connected under a legacy modify grant; current connections are read-only and cannot create drafts; the tool says so if not.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of the connected mailbox to create the draft in. Omit to use the first connected mailbox.",
"type": "string"
},
"body": {
"description": "The plain-text body of the draft.",
"type": "string"
},
"cc": {
"description": "Optional cc address(es), comma-separated.",
"type": "string"
},
"subject": {
"description": "The email subject line.",
"type": "string"
},
"to": {
"description": "The recipient's email address (comma-separate several).",
"type": "string"
}
},
"required": [
"to",
"subject",
"body"
],
"type": "object"
},
"name": "create_gmail_draft",
"outputSchema": null
},
{
"description": "Create a new object in the user's graph. Use when they ask to add something — a project, note, fact, web link, person, company, product, event, group, tag, or prompt. If an object of the same type and name already exists it is returned instead of duplicated; pass allow_duplicate=true only when the user confirms they want a second one. Set any of the type's own fields at creation with 'fields' (a domain_name's asking_price and source, a contact's phone); a name the type does not have is reported back with the names it accepts. Returns the object with its object_id for follow-up connecting.",
"inputSchema": {
"properties": {
"allow_duplicate": {
"description": "Create even if the same type+name exists.",
"type": "boolean"
},
"description": {
"description": "Optional longer description.",
"type": "string"
},
"domain": {
"description": "For company objects: the company's website domain (e.g. 'openai.com'). Connects the company to its shared enrichment profile and dedupes per domain.",
"type": "string"
},
"email": {
"description": "For contacts: their email address. Dedupes per address, and fills the address in on a contact of the same name that has none.",
"type": "string"
},
"fields": {
"description": "The type's own fields to set on the new object, e.g. {'asking_price': 75000, 'source': 'GritBrokerage.com'}.",
"type": "object"
},
"name": {
"description": "The object's name (e.g. 'UNBOUND26 Keynote').",
"type": "string"
},
"type": {
"description": "What kind of object to create.",
"enum": [
"contact",
"company",
"product",
"event",
"group",
"project",
"note",
"fact",
"web_link",
"tag",
"prompt",
"domain_name",
"linkedin_plan"
],
"type": "string"
},
"url": {
"description": "Optional URL (the link itself for web_link).",
"type": "string"
}
},
"required": [
"type",
"name"
],
"type": "object"
},
"name": "create_graph_object",
"outputSchema": null
},
{
"description": "Set up a standing search the user wants watched — 'track LinkedIn posts that mention hubspot', 'track tweets mentioning @dharmesh', 'watch acme.com/pricing for changes'. query is what to watch for; tracker_type says where to watch (LinkedIn posts unless they ask for tweets/X or a specific page URL — a URL to watch means web_page, with the URL in url and query as a short label for it). linkedin_post and twitter_search requests become a daily cloud agent that emails a digest of new posts; web_page creates a tracker in their brain that runs daily and emails changes, filtered by the prompt. Always give the user the returned page_url as a link — that page is where they review and manage it.",
"inputSchema": {
"properties": {
"prompt": {
"description": "The user's tracking request in their own words, verbatim, filters included (e.g. 'Track linkedin posts that mention hubspot and have more than 10 likes'). Stored on the tracker and later applied as a filter to what the search returns.",
"type": "string"
},
"query": {
"description": "The search keywords to watch for (e.g. 'hubspot').",
"type": "string"
},
"tracker_type": {
"description": "Where to watch. Defaults to linkedin_post.",
"enum": [
"linkedin_post",
"twitter_search",
"web_page"
],
"type": "string"
},
"url": {
"description": "web_page trackers only: the page URL to watch for changes.",
"type": "string"
}
},
"required": [
"query",
"prompt"
],
"type": "object"
},
"name": "create_tracker",
"outputSchema": null
},
{
"description": "Delete an object from the user's graph. Use only when the user explicitly asks to delete or remove a specific object — never to tidy up on your own initiative. The delete is soft: the object disappears from lists, search, and chat, but its data is retained and a restore is possible later. Identify the object by object_id (search_graph_objects returns it). Only objects the user owns can be deleted, and never their root user node. In chat, this tool does not delete directly — it returns instructions for showing the user a confirmation card, and the card performs the delete.",
"inputSchema": {
"properties": {
"object_id": {
"description": "The object_id of the object to delete.",
"type": "string"
}
},
"required": [
"object_id"
],
"type": "object"
},
"name": "delete_graph_object",
"outputSchema": null
},
{
"description": "Delete EVERY object of one type from the user's graph, however many there are: what to reach for when they ask to clear out a whole category ('delete all my HubSpot contacts') rather than one record. Deleting one object is delete_graph_object instead. This delete is permanent, and at this scale it is the only kind that helps: a synced portal can be millions of records. Use only when the user explicitly asked for a category to go, never on your own initiative, and name one type per call (contacts and companies are two calls). In chat this tool deletes nothing: it counts the records and returns instructions for a confirmation card, and the user's click starts the deletion.",
"inputSchema": {
"properties": {
"object_type": {
"description": "The type to clear out, e.g. 'hubspot_contact'. search_graph_objects and the brain's type counts both report types.",
"type": "string"
}
},
"required": [
"object_type"
],
"type": "object"
},
"name": "delete_graph_objects",
"outputSchema": null
},
{
"description": "Delete a given list of objects from the user's graph, up to 200 object_ids in one call. Use only when the user explicitly asked for these particular objects to go, never to tidy up on your own initiative. The delete is soft and reversible: the objects drop out of lists, search and chat, and restore_graph_objects with the returned deleted_ids brings them back. One object is delete_graph_object; every object of a type is delete_graph_objects. Only objects the user owns are deleted, never their root user node; the rest come back as skipped. Not available in the YouSpot chat, where the user ticks the rows in their lists instead.",
"inputSchema": {
"properties": {
"object_ids": {
"description": "The object_ids, at most 200.",
"items": {
"type": "string"
},
"type": "array"
}
},
"required": [
"object_ids"
],
"type": "object"
},
"name": "delete_selected_graph_objects",
"outputSchema": null
},
{
"description": "Delete one connection between two objects in the user's graph — the edge from_object_id -> to_object_id of the given connection_type, nothing else; both objects stay. Use get_graph_object to see an object's connections and their types and directions first.",
"inputSchema": {
"properties": {
"connection_type": {
"description": "The relationship name of the edge to delete.",
"type": "string"
},
"from_object_id": {
"description": "The edge starts here (exact object_id).",
"type": "string"
},
"to_object_id": {
"description": "The edge points here (exact object_id).",
"type": "string"
}
},
"required": [
"from_object_id",
"to_object_id",
"connection_type"
],
"type": "object"
},
"name": "disconnect_graph_objects",
"outputSchema": null
},
{
"description": "Disconnect one connected account. Destructive and not undoable: disconnecting a HubSpot portal also deletes every record it synced. Never call this to check anything; call list_integrations for that. Only call it when the user has asked to disconnect, in their own words, naming what.",
"inputSchema": {
"properties": {
"account": {
"description": "Which account, by the exact label list_integrations reported. Required when more than one is connected.",
"type": "string"
},
"key": {
"description": "Which integration, e.g. 'gmail' or 'hubspot'.",
"type": "string"
}
},
"required": [
"key"
],
"type": "object"
},
"name": "disconnect_integration",
"outputSchema": null
},
{
"description": "In the YouSpot chat only: draft a standing errand the user asked for, so they can turn it on with one tap. Use this whenever they ask for something to happen on its own from now on: 'tell me when...', 'every morning...', 'notify me...', 'remind me each...', 'watch for...', 'let me know if...'. Never answer that you cannot set up a reminder, a watch or a recurring email; this is how you set one up. It creates nothing and turns nothing on, so it is safe to call as soon as the ask is clear. If the ask names a person for an email watch, look their address up first with search_graph_objects or search_connections and pass it as trigger.from; if two people match, ask which with the ask_user card instead of calling this. If they gave no address and none is on record, still draft it with trigger.from empty and say in your own words that it will watch the whole inbox. Pass the schedule or trigger fields only to override what the request plainly said; leave them out and the request is read for them.",
"inputSchema": {
"properties": {
"name": {
"description": "Override the drafted name. Two to four words, sentence case.",
"type": "string"
},
"request": {
"description": "What the user asked for, in their own words, plus anything the conversation has settled since (a name, an address, a time).",
"type": "string"
},
"schedule": {
"description": "Override when it runs: {'time': 'HH:MM'} plus {'days': [0-6]} for daily (0=Sunday), {'day': 0-6} for weekly, {'minute': 0-59} for hourly.",
"type": "object"
},
"schedule_type": {
"description": "Override how it runs. 'trigger' means an event rather than a clock.",
"enum": [
"once",
"hourly",
"daily",
"weekly",
"trigger"
],
"type": "string"
},
"trigger": {
"description": "Override what it watches, with schedule_type 'trigger': {'event': 'email.received', 'from': '<address or domain, empty for any>', 'frequency': 'hourly'} or {'event': 'object.tagged', 'tag': '<tag>'}.",
"type": "object"
}
},
"required": [
"request"
],
"type": "object"
},
"name": "draft_cloud_agent",
"outputSchema": null
},
{
"description": "Put a generated email (an artifact_id from generate_email) in the user's Gmail drafts, addressed to the recipients they named. Nothing is sent. The email has to be unlocked first: a watermarked draft is refused and the user unlocks it from the card. Only works on mailboxes connected under a legacy modify grant; the tool says so if not. Returns a link to the draft.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of the connected mailbox to draft in. Omit for the first one.",
"type": "string"
},
"artifact_id": {
"description": "The artifact_id generate_email returned.",
"type": "string"
},
"cc": {
"description": "Optional cc address(es), comma-separated.",
"type": "string"
},
"to": {
"description": "The recipient's email address (comma-separate several).",
"type": "string"
}
},
"required": [
"artifact_id",
"to"
],
"type": "object"
},
"name": "draft_email_in_gmail",
"outputSchema": null
},
{
"description": "Write every post in this week's post plan as a draft, in the user's own voice, saved to their brain as a note per post and linked to the plan. Posts that already have a draft are left as they are. Use for 'write the posts in my plan', 'draft this week's posts', 'write them all'. For one post from finished work that is not on a plan, use the restate skill instead. Nothing is posted to LinkedIn: the user copies the draft and posts it. error no_plan means there is no plan this week, so offer to make one first. Link each draft as [subject](/graph/object/<object_id> \"note\") and say they can edit anything, then end with [See your week](/linkedin/manager), the page where they can read, copy and schedule each one.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "draft_my_planned_posts",
"outputSchema": null
},
{
"description": "Read a public website and save its brand (colors, fonts, radius and logo) as a new brand kit that needs the user's review. Costs 3 credits, charged only when the kit is saved. Takes up to about a minute. Call list_brand_kits first and reuse a matching website's kit unless the user explicitly wants another extraction. Do not call this again to retry. Returns brand_kit_id, open_url and source_url.",
"inputSchema": {
"properties": {
"website_url": {
"description": "The website address, like acme.com.",
"type": "string"
}
},
"required": [
"website_url"
],
"type": "object"
},
"name": "extract_brand_kit",
"outputSchema": null
},
{
"description": "Search for companies by describing them in plain English — the same engine behind the ProspectFinder app. Handles industry, size, location, funding stage and investors in one query: 'CRM software companies with more than 1,000 employees', 'Series A AI startups in Boston', 'YC-funded fintechs'. Returns name, domain, employee count and description per company. Use this for discovering companies out in the world; for companies/people the user already knows, use their graph and connection tools instead. Results can then be added to the user's graph with the graph tools if they ask. The result includes a result_id that chat surfaces can use to render the list as a live prospect_list card.",
"inputSchema": {
"properties": {
"limit": {
"description": "Max companies to return (default 10, max 25).",
"type": "integer"
},
"query": {
"description": "Plain-English description of the companies to find (industry, size, location, funding, investors).",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "find_companies",
"outputSchema": null
},
{
"description": "Look through the connected mailboxes for newsletters and list the publications sending them, with how many arrived and how many the owner opened. Reads no bodies and changes nothing: this is the question, not the answer. Each sender comes back with a `status` — 'undecided' means the owner has never said, 'allowed' means read it, 'blocked' means do not. Our guess at what each one is rides on `classification`: 'newsletter' for something written, 'promotion' for a retailer. The guess only sorts the list; the owner decides. Show them the undecided ones, most frequent first, say which look like promotions, and ask which they want read.",
"inputSchema": {
"properties": {
"days": {
"description": "How far back to look. Default 30.",
"type": "integer"
}
},
"type": "object"
},
"name": "find_my_newsletters",
"outputSchema": null
},
{
"description": "How two objects in the user's graph are connected: the shortest chain of real relationships between them, up to 3 hops, e.g. person -[worked_with]- person -[works_at]- company. Only deliberate relationships count — bulk-import and system-inferred edges are excluded, so a path is evidence. Returns the path as a list of hops, and an EMPTY list when there is no connection: report that honestly, never invent a path.",
"inputSchema": {
"properties": {
"from_object_id": {
"description": "Where the path starts (exact object_id).",
"type": "string"
},
"to_object_id": {
"description": "Where the path ends (exact object_id).",
"type": "string"
}
},
"required": [
"from_object_id",
"to_object_id"
],
"type": "object"
},
"name": "find_paths",
"outputSchema": null
},
{
"description": "Render one branded email in a brand kit and save it to the user's files: any email the user describes, from a cold intro or a follow-up to a newsletter, an invitation, a launch note or a receipt. Nothing is sent. Drafts are limited to 20 per day. Templates: 'letter' takes preheader, signoff, footer_note; 'announcement' takes headline (required), preheader, cta_label, cta_url, signoff, footer_note; 'newsletter' takes issue_label, headline (required), preheader, cta_label, cta_url, signoff, footer_note; 'invitation' takes invite_label, event_name (required), when, where, preheader, cta_label, cta_url, signoff, footer_note; 'notification' takes status_label, headline (required), cta_label, cta_url, footer_note; 'onboarding' takes headline (required), preheader, cta_label, cta_url, signoff, footer_note; 'receipt' takes headline (required), order_label, order_date, cta_label, cta_url, footer_note. Pick the template whose shape fits the job and write the subject, props and body yourself in the user's voice; the template is a layout, not a limit on what the email can say. Write the body as markdown (paragraphs, lists, links, tables) or as blocks, never both. header 'band' paints the header in the brand color, 'plain' keeps it white; align is left or center; both default to the template's layout. Leave brand_kit_id out to use the space's default brand. It costs 1 credit. Returns the artifact id; call draft_email_in_gmail with it. Do not call this again to retry.",
"inputSchema": {
"properties": {
"align": {
"enum": [
"left",
"center"
],
"type": "string"
},
"blocks": {
"description": "The body as blocks.",
"items": {
"description": "One block: heading (text); text (markdown); button (label, url); image (url, alt); stats (items: [{label, value}] up to 4); steps (items: [{title, text}] up to 8); lines (items: [{label, value}] up to 8, total); quote (text, attribution); divider.",
"properties": {
"alt": {
"type": "string"
},
"attribution": {
"type": "string"
},
"items": {
"items": {
"properties": {
"label": {
"type": "string"
},
"text": {
"type": "string"
},
"title": {
"type": "string"
},
"value": {
"type": "string"
}
},
"type": "object"
},
"type": "array"
},
"label": {
"type": "string"
},
"markdown": {
"type": "string"
},
"text": {
"type": "string"
},
"total": {
"type": "string"
},
"type": {
"enum": [
"heading",
"text",
"button",
"image",
"stats",
"steps",
"lines",
"quote",
"divider"
],
"type": "string"
},
"url": {
"type": "string"
}
},
"required": [
"type"
],
"type": "object"
},
"type": "array"
},
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
},
"header": {
"enum": [
"band",
"plain"
],
"type": "string"
},
"markdown": {
"description": "The body as markdown.",
"type": "string"
},
"props": {
"additionalProperties": {
"type": "string"
},
"description": "Text fields for the template, all strings.",
"type": "object"
},
"saved_template_id": {
"description": "A saved_template_id from list_templates; its inputs seed the ones you pass.",
"type": "string"
},
"subject": {
"description": "The subject line.",
"type": "string"
},
"template_id": {
"enum": [
"letter",
"announcement",
"newsletter",
"invitation",
"notification",
"onboarding",
"receipt"
],
"type": "string"
}
},
"required": [
"template_id"
],
"type": "object"
},
"name": "generate_email",
"outputSchema": null
},
{
"description": "Generate a photo for 1 credit to go behind a social image, from a description of the scene. Only when the user asks for a photo, picture or background. Describe the scene, the light and where to leave empty space for the headline; never ask for text, words or logos in it. size is the canvas it will go on. Returns a file_id for generate_og_image's background_file_id.",
"inputSchema": {
"properties": {
"prompt": {
"description": "The scene, in a sentence or two.",
"type": "string"
},
"size": {
"description": "Where the image will be posted. Sizes: 'og' 1200x630 (The card X, LinkedIn, Slack and iMessage show under a link); 'square' 1080x1080 (An Instagram, LinkedIn or Facebook feed post); 'portrait' 1080x1350 (A taller Instagram or LinkedIn feed post); 'story' 1080x1920 (An Instagram or Facebook story, or a Reels cover); 'landscape' 1280x720 (A YouTube thumbnail or a 16:9 slide); 'facebook_cover' 1640x624 (A Facebook page or profile cover photo, shown at 820 by 312); 'linkedin_banner' 1584x396 (The background image on a LinkedIn profile); 'x_header' 1500x500 (The header image on an X profile). Left out it is 'og'.",
"enum": [
"og",
"square",
"portrait",
"story",
"landscape",
"facebook_cover",
"linkedin_banner",
"x_header"
],
"type": "string"
}
},
"required": [
"prompt"
],
"type": "object"
},
"name": "generate_image_background",
"outputSchema": null
},
{
"description": "Write one document in the user's brand and save it to their files: anything they want to read in chat rather than print or send, from a to-do list or a checklist to a plan, notes, a brief or a summary they asked to keep. Takes the markdown, an optional title (the first heading otherwise) and an optional brand_kit_id. The card renders the whole document in the brand, so never paste the markdown into the reply as well. Nothing renders to a file the user has to open: there is no watermark, nothing to unlock and nothing to pay. Use generate_pdf instead when they want a document to print, attach or send. Do not call this again to retry.",
"inputSchema": {
"properties": {
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
},
"markdown": {
"description": "The whole document as markdown.",
"type": "string"
},
"title": {
"description": "The document title. The first heading otherwise.",
"type": "string"
}
},
"required": [
"markdown"
],
"type": "object"
},
"name": "generate_markdown",
"outputSchema": null
},
{
"description": "Render one branded image in a brand kit for 1 credit and save it to the user's files: a link preview card, a social post, a story, a cover photo, a profile banner or a thumbnail. Drafts are limited to 20 per day. template_id 'simple' takes props label, title and description; 'blog' takes category, title, excerpt, author and meta; 'image' draws only the background and takes title, a name for the image. title is required. size picks the canvas for where it will be posted: 'og' 1200x630 (The card X, LinkedIn, Slack and iMessage show under a link); 'square' 1080x1080 (An Instagram, LinkedIn or Facebook feed post); 'portrait' 1080x1350 (A taller Instagram or LinkedIn feed post); 'story' 1080x1920 (An Instagram or Facebook story, or a Reels cover); 'landscape' 1280x720 (A YouTube thumbnail or a 16:9 slide); 'facebook_cover' 1640x624 (A Facebook page or profile cover photo, shown at 820 by 312); 'linkedin_banner' 1584x396 (The background image on a LinkedIn profile); 'x_header' 1500x500 (The header image on an X profile). Write the text yourself from what the user said and their brand; never leave a field blank because they did not dictate it. Leave brand_kit_id out to use the space's default brand. background_file_id puts a photo behind the text: an id from generate_image_background or an image the user uploaded. Do not call this again to retry. Returns the artifact id.",
"inputSchema": {
"properties": {
"align": {
"description": "Text and brand alignment. Defaults to the template's layout.",
"enum": [
"left",
"center",
"right"
],
"type": "string"
},
"appearance": {
"enum": [
"light",
"dark"
],
"type": "string"
},
"background_file_id": {
"description": "A photo to put behind the text, by file id.",
"type": "string"
},
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
},
"gradient": {
"description": "Brand gradient background (default true); false uses a flat background.",
"type": "boolean"
},
"props": {
"additionalProperties": {
"type": "string"
},
"description": "Text fields for the template, all strings.",
"type": "object"
},
"saved_template_id": {
"description": "A saved_template_id from list_templates; its inputs seed the ones you pass.",
"type": "string"
},
"size": {
"description": "Where the image will be posted. Sizes: 'og' 1200x630 (The card X, LinkedIn, Slack and iMessage show under a link); 'square' 1080x1080 (An Instagram, LinkedIn or Facebook feed post); 'portrait' 1080x1350 (A taller Instagram or LinkedIn feed post); 'story' 1080x1920 (An Instagram or Facebook story, or a Reels cover); 'landscape' 1280x720 (A YouTube thumbnail or a 16:9 slide); 'facebook_cover' 1640x624 (A Facebook page or profile cover photo, shown at 820 by 312); 'linkedin_banner' 1584x396 (The background image on a LinkedIn profile); 'x_header' 1500x500 (The header image on an X profile). Left out it is 'og'.",
"enum": [
"og",
"square",
"portrait",
"story",
"landscape",
"facebook_cover",
"linkedin_banner",
"x_header"
],
"type": "string"
},
"template_id": {
"enum": [
"simple",
"blog",
"image"
],
"type": "string"
}
},
"required": [
"template_id"
],
"type": "object"
},
"name": "generate_og_image",
"outputSchema": null
},
{
"description": "Render one branded PDF in a brand kit and save it to the user's files: any document the user describes, from an invoice or a statement to a one-pager, a proposal, a memo, a case study, an agenda or a report. Drafts are limited to 20 per day. Templates: 'invoice' takes items of description, quantity, unit_price, up to 30 plus props invoice_number, issued_on, due_on, bill_to, currency, tax_rate, notes; 'statement' takes items of description, date, amount, up to 30 plus props account, account_of, period_start, period_end, currency, opening_balance, notes; 'report' takes markdown or blocks plus props subtitle, author, dated; 'letter' takes markdown or blocks plus props recipient, dated, signoff; 'proposal' takes markdown or blocks plus props client, valid_until, prepared_by. A document template renders whatever markdown you give it, so an unfamiliar ask (a press release, a checklist, a brief) is still a report, letter or proposal with the right headings. Line item fields are all strings, and every date is YYYY-MM-DD. Write a document as markdown (headings, lists, tables) or as blocks, never both, and its first heading becomes the title unless you pass a title. Leave brand_kit_id out to use the space's default brand. Returns the artifact id and how many pages it came to. It costs 1 credit. Do not call this again to retry.",
"inputSchema": {
"properties": {
"blocks": {
"description": "The document body as blocks.",
"items": {
"description": "One block: heading (text); text (markdown); table (columns: [{label}] up to 6, rows: [{cells}] up to 40); stats (items: [{label, value}] up to 4); callout (title, markdown); signature (name, title, date); page_break.",
"properties": {
"columns": {
"items": {
"properties": {
"label": {
"type": "string"
}
},
"type": "object"
},
"type": "array"
},
"date": {
"type": "string"
},
"items": {
"items": {
"properties": {
"label": {
"type": "string"
},
"value": {
"type": "string"
}
},
"type": "object"
},
"type": "array"
},
"markdown": {
"type": "string"
},
"name": {
"type": "string"
},
"rows": {
"items": {
"properties": {
"cells": {
"type": "string"
}
},
"type": "object"
},
"type": "array"
},
"text": {
"type": "string"
},
"title": {
"type": "string"
},
"type": {
"enum": [
"heading",
"text",
"table",
"stats",
"callout",
"signature",
"page_break"
],
"type": "string"
}
},
"required": [
"type"
],
"type": "object"
},
"type": "array"
},
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
},
"footer_text": {
"description": "The footer line. Empty string for no footer; left out it is the brand name.",
"type": "string"
},
"items": {
"description": "Line items, in the fields the template names.",
"items": {
"properties": {
"amount": {
"type": "string"
},
"date": {
"type": "string"
},
"description": {
"type": "string"
},
"quantity": {
"type": "string"
},
"unit_price": {
"type": "string"
}
},
"type": "object"
},
"type": "array"
},
"markdown": {
"description": "The document body as markdown.",
"type": "string"
},
"page": {
"description": "Page size; left out it follows the brand kit.",
"enum": [
"letter",
"a4"
],
"type": "string"
},
"page_numbers": {
"enum": [
"on",
"off"
],
"type": "string"
},
"props": {
"additionalProperties": {
"type": "string"
},
"description": "Text fields for the template, all strings.",
"type": "object"
},
"saved_template_id": {
"description": "A saved_template_id from list_templates; its inputs seed the ones you pass.",
"type": "string"
},
"template_id": {
"enum": [
"invoice",
"statement",
"report",
"letter",
"proposal"
],
"type": "string"
},
"title": {
"description": "The document title. Optional.",
"type": "string"
}
},
"required": [
"template_id"
],
"type": "object"
},
"name": "generate_pdf",
"outputSchema": null
},
{
"description": "Draft one Substack post and save it to the user's files, ready to paste into their Substack editor. Nothing is published and nothing is sent. Drafts are limited to 20 per day. Templates: 'post' takes signoff; 'digest' takes intro, signoff. Write the body as markdown (paragraphs, lists, links) or as blocks, never both. The title and subtitle are the post's own headline and standfirst. audience is everyone, paid or founding. It costs 1 credit. Do not call this again to retry.",
"inputSchema": {
"properties": {
"audience": {
"enum": [
"everyone",
"paid",
"founding"
],
"type": "string"
},
"blocks": {
"description": "The body as blocks.",
"items": {
"description": "One block: heading (text); text (markdown); image (url, alt); quote (text, attribution); divider.",
"properties": {
"alt": {
"type": "string"
},
"attribution": {
"type": "string"
},
"markdown": {
"type": "string"
},
"text": {
"type": "string"
},
"type": {
"enum": [
"heading",
"text",
"image",
"quote",
"divider"
],
"type": "string"
},
"url": {
"type": "string"
}
},
"required": [
"type"
],
"type": "object"
},
"type": "array"
},
"markdown": {
"description": "The body as markdown.",
"type": "string"
},
"props": {
"additionalProperties": {
"type": "string"
},
"description": "Text fields for the template, all strings.",
"type": "object"
},
"subtitle": {
"description": "The line under the headline.",
"type": "string"
},
"template_id": {
"enum": [
"post",
"digest"
],
"type": "string"
},
"title": {
"description": "The post's headline.",
"type": "string"
}
},
"required": [
"template_id",
"title"
],
"type": "object"
},
"name": "generate_substack_post",
"outputSchema": null
},
{
"description": "Save a view the user wants to keep: a page in the view language that renders with live data, like a dashboard, a Markdown document, a feed of posts or a page of generated emails and images. Takes the source, the spec_version it was written against, an optional title and optional state. saved_template_id starts from a view template saved earlier; anything you pass replaces its value. Views are free: no watermark and nothing to unlock. Returns the artifact_id.",
"inputSchema": {
"properties": {
"saved_template_id": {
"description": "A saved_template_id from list_templates; its inputs seed the ones you pass.",
"type": "string"
},
"source": {
"description": "The whole view in the view language, one statement per line.",
"type": "string"
},
"spec_version": {
"description": "The view library version the source was written against.",
"type": "string"
},
"state": {
"description": "The view's saved state values, keyed by name.",
"type": "object"
},
"title": {
"description": "A short name the user would recognise.",
"type": "string"
}
},
"type": "object"
},
"name": "generate_view",
"outputSchema": null
},
{
"description": "Read one generated image, email or PDF by artifact_id: its template, brand, status and, for the user's own drafts, the inputs it was made from, so an edit can call the generator again with them changed.",
"inputSchema": {
"properties": {
"artifact_id": {
"description": "An artifact_id from list_artifacts or a generator.",
"type": "string"
}
},
"required": [
"artifact_id"
],
"type": "object"
},
"name": "get_artifact",
"outputSchema": null
},
{
"description": "Read one brand kit with its colors, fonts, radius and domain, whether it is the space default and whether it still needs the user's review. Returns the logo, extraction source_url and canonical open_url, with an inline view for supported MCP hosts. Use those URLs rather than constructing a link. Call it when the user asks about one brand's details or before editing a kit.",
"inputSchema": {
"properties": {
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
}
},
"required": [
"brand_kit_id"
],
"type": "object"
},
"name": "get_brand_kit",
"outputSchema": null
},
{
"description": "List events from the user's connected calendars, Google and Outlook together, ordered by start time: summary, start/end, location, organizer, attendees and their RSVP status, a meeting link when there is one, and which provider and account each event came from (Outlook events carry a web_link that opens them in Outlook). With no time range it returns upcoming events from now. `time_min` and `time_max` are RFC3339 timestamps ('2026-08-19T00:00:00Z'), so 'what's on my calendar tomorrow' is time_min/time_max spanning that day; past ranges work too. `query` free-text matches event titles, descriptions, and attendees. For 'how many meetings' questions over long ranges (a quarter, a year), set count_only=true; it sweeps the whole range and returns the total plus a per-month breakdown instead of the events themselves, so a 12-month count is one call. By default this reads each account's main calendar; to read a named calendar ('my Family calendar'), get its id from list_google_calendars or list_outlook_calendars, then pass calendar_id together with that account. If the result says no calendar is connected (or the account lacks calendar access), show the user the message and link them to https://youspot.com/user/integrations/gmail.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of one connected Google account or Outlook mailbox. Omit to read all connected calendars.",
"type": "string"
},
"calendar_id": {
"description": "Which calendar to read: an id from list_google_calendars or list_outlook_calendars. Omit for each account's main calendar.",
"type": "string"
},
"count_only": {
"description": "Return only counts (total and per calendar month) instead of the events. Sweeps far more of the range (up to 12,500 events) than an event listing can. Use for totals and \"how many\" questions.",
"type": "boolean"
},
"max_results": {
"description": "Max events to return (default 10, max 250).",
"type": "integer"
},
"query": {
"description": "Free-text search over events (titles, descriptions, attendees). Omit to list everything in the range.",
"type": "string"
},
"time_max": {
"description": "Latest event start, RFC3339.",
"type": "string"
},
"time_min": {
"description": "Earliest event end, RFC3339 ('2026-08-19T00:00:00Z'). Defaults to now when time_max is also omitted.",
"type": "string"
}
},
"type": "object"
},
"name": "get_calendar_events",
"outputSchema": null
},
{
"description": "Get the full profile for one of the user's LinkedIn connections: work history, education, skills, and their About summary. Use this after search_connections when you need depth on a specific person. Identify them by name, or by linkedin_url for an exact match. A found:false response carries the user's imported-connection count: if no_imported_data is set, nothing was searched, so report the missing import rather than a missing person.",
"inputSchema": {
"properties": {
"linkedin_url": {
"description": "Exact LinkedIn profile URL, if known.",
"type": "string"
},
"name": {
"description": "The connection's name (full or partial).",
"type": "string"
}
},
"type": "object"
},
"name": "get_connection_details",
"outputSchema": null
},
{
"description": "Overview of the user's imported LinkedIn data: how many connections, invitations and messages they have, when it was last imported, and the companies they know the most people at. Use this for questions about the shape of their network as a whole, or how much data is loaded.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "get_connections_summary",
"outputSchema": null
},
{
"description": "Look up the public registration (WHOIS) record for a website domain: who registered it, which registrar holds it, when it was created and last updated, when it expires, its nameservers, and its registry status codes. Use this ONLY when the user explicitly asks about the domain/WHOIS/DNS itself: 'who owns stripe.com?', 'when does our domain expire?', 'how old is this domain?', 'is this domain registered?'. Never call it for general questions about a company — this is public registrar data about a domain on the internet; it is not the user's own account data, and it says nothing about the company behind the domain. Registrant details are often masked by a privacy service, in which case the registrant fields name the proxy rather than the real owner; say so instead of presenting the proxy as the owner.",
"inputSchema": {
"properties": {
"domain": {
"description": "The domain to look up, e.g. \"hubspot.com\". A full URL is accepted and reduced to the domain.",
"type": "string"
}
},
"required": [
"domain"
],
"type": "object"
},
"name": "get_domain_info",
"outputSchema": null
},
{
"description": "The search keywords a website is buying ads on (paid, PPC, AdWords, Google Ads) and the ones it ranks for organically, with monthly search volume, cost per click, position, landing URL and share of the site's search traffic, plus domain totals: paid keyword count, paid traffic and estimated monthly ad spend, and the organic equivalents. Use this when the user asks what keywords a company is buying or bidding on, what it spends on search ads, what it ranks for, or wants to compare competitors' search strategies. Takes a domain (preferred) or a company name. US search data only.",
"inputSchema": {
"properties": {
"company": {
"description": "The website domain (\"monday.com\", preferred) or company name.",
"type": "string"
},
"kind": {
"description": "Which keywords to return. Default paid.",
"enum": [
"paid",
"organic",
"both"
],
"type": "string"
},
"limit": {
"description": "Keywords per kind, 1 to 100. Default 20.",
"type": "integer"
}
},
"required": [
"company"
],
"type": "object"
},
"name": "get_domain_keywords",
"outputSchema": null
},
{
"description": "Estimate what a domain name is worth (the /domainvalue appraisal): an estimated market value in dollars with the signals behind it — comparable sales, marketplace listings, an appraisal model, SEO data. Use when the user asks what a domain is worth, whether one is a good buy, or to compare domain values. A fresh appraisal can take up to a minute; repeat lookups within 48 hours are cached and instant. Include the report_url in your reply so the user can open the full report.",
"inputSchema": {
"properties": {
"domain": {
"description": "The domain to appraise, e.g. \"startup.com\". A full URL is accepted and reduced to the domain.",
"type": "string"
}
},
"required": [
"domain"
],
"type": "object"
},
"name": "get_domain_value",
"outputSchema": null
},
{
"description": "Fetch one Gmail message by its id from the user's connected mailbox, including the full plain-text body (rare header-only connections get headers and the snippet instead). Use this to read a message found via search_gmail_messages (which returns ids and snippets only), or when a triggering event hands you a Gmail message_id to analyze.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of the connected mailbox holding the message. Omit to try all connected mailboxes.",
"type": "string"
},
"message_id": {
"description": "The Gmail message id.",
"type": "string"
}
},
"required": [
"message_id"
],
"type": "object"
},
"name": "get_gmail_message",
"outputSchema": null
},
{
"description": "One Granola meeting in full: the summary Granola wrote (Markdown), who attended, when, the space, a link to Granola, and the start of the transcript. `note` is an object id from get_granola_notes, a Granola note id, or a title. Pass `transcript` true for the transcript rather than the summary when the user asks what exactly was said.",
"inputSchema": {
"properties": {
"note": {
"description": "Object id, Granola id, or title of the meeting.",
"type": "string"
},
"transcript": {
"description": "Return the transcript instead of the summary.",
"type": "boolean"
}
},
"required": [
"note"
],
"type": "object"
},
"name": "get_granola_note",
"outputSchema": null
},
{
"description": "The user's Granola meeting notes already synced into their brain, newest first: title, when the meeting was, who attended, the space, and a link. `days` bounds how far back (default 30); `query` keeps notes whose title, summary or attendees mention a word or name; `attendee` keeps meetings with that person. Fast, no Granola call. Follow up with get_granola_note for the summary and transcript of one meeting.",
"inputSchema": {
"properties": {
"attendee": {
"description": "Only meetings this person attended (name or email fragment).",
"type": "string"
},
"days": {
"description": "Meetings in the last N days (default 30). 0 for all time.",
"type": "integer"
},
"limit": {
"description": "Max notes (default 10, max 50).",
"type": "integer"
},
"query": {
"description": "A word, phrase or name to look for in title, summary or attendees.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "get_granola_notes",
"outputSchema": null
},
{
"description": "Whether Granola is connected and how the sync is doing: the account, the shared spaces the key can see, when it last synced, and how many notes are in the brain. Use it when a user asks why a meeting is missing or whether Granola is set up.",
"inputSchema": {
"properties": {},
"required": [],
"type": "object"
},
"name": "get_granola_status",
"outputSchema": null
},
{
"description": "Get one object from the user's graph, with the objects connected to it (its edges, e.g. a person's spaces, a note's subject). Identify it by object_id (exact, preferred — search and list return it) or by name. Use this when the user asks about a specific thing in their graph, or to follow a connection you found on another object.",
"inputSchema": {
"properties": {
"name": {
"description": "The object's name (full or partial).",
"type": "string"
},
"object_id": {
"description": "Exact node id (e.g. web_aBc123), if known.",
"type": "string"
}
},
"type": "object"
},
"name": "get_graph_object",
"outputSchema": null
},
{
"description": "Overview of the user's synced HubSpot data: which portals they have connected, how many contacts and companies came from each, and when each was last synced. Use this for questions about how much HubSpot data they have, which portals are connected, or whether their data is up to date — and to check they have any data before promising an answer. For questions about the records themselves, use ask_about_hubspot_contacts or ask_about_hubspot_companies.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "get_hubspot_summary",
"outputSchema": null
},
{
"description": "The URL that starts connecting one integration, for surfaces that cannot render a card (Slack, SMS, email). In chat, show the integrations_list card instead. Never claim to have connected anything: only the user can grant it, in their browser.",
"inputSchema": {
"properties": {
"key": {
"description": "Which integration, e.g. 'gmail' or 'hubspot'.",
"type": "string"
}
},
"required": [
"key"
],
"type": "object"
},
"name": "get_integration_connect_url",
"outputSchema": null
},
{
"description": "Read the user's LinkedIn message history (DMs) with one person, from their imported LinkedIn export: every conversation that person is in, oldest first, with who sent each message and its full text. Use for 'what did I message Sander?', 'did she ever reply?', 'show me my LinkedIn thread with Tom' and before drafting a follow-up to someone the user has messaged. Pass a name or a LinkedIn profile URL. If the name matches several people it returns candidates to choose from.",
"inputSchema": {
"properties": {
"limit": {
"description": "How many of the most recent messages to return (default 60, max 150).",
"type": "integer"
},
"person": {
"description": "The person's name as it appears on LinkedIn, or their profile URL.",
"type": "string"
}
},
"required": [
"person"
],
"type": "object"
},
"name": "get_linkedin_conversation",
"outputSchema": null
},
{
"description": "Overview of the user's imported LinkedIn messages (DMs): how many messages and conversations they have, the date range covered, and how many they sent versus received. Use for 'how many messages do I have?' and questions about the shape of their message history.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "get_messages_summary",
"outputSchema": null
},
{
"description": "The posts the user bookmarked on X (Twitter), newest first — author @handle, text, date, engagement, and link, plus an author_counts rollup of how often each author appears across ALL their bookmarks (use it directly for questions like 'whose posts do I bookmark most?'). Reads the synced archive; bookmarks sync daily for accounts that granted bookmark access. `query` filters bookmark text, `author` narrows to one @handle. If it reports nothing synced, the account may need reconnecting to grant bookmark access; the result carries the link.",
"inputSchema": {
"properties": {
"author": {
"description": "Only bookmarks of posts by this @handle.",
"type": "string"
},
"limit": {
"description": "Max bookmarks to return (default 50, max 200).",
"type": "integer"
},
"query": {
"description": "Case-insensitive substring to filter bookmark text.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "get_my_bookmarks",
"outputSchema": null
},
{
"description": "The user's own LinkedIn posts with engagement numbers (reactions, likes, comments, shares): newest first by default, their earliest with sort='oldest', or their best-performing with sort='top'. sort='top' is what answers 'my top 10 posts', 'my best posts' and 'what performed well'. Answer those from here rather than from linkedin_analytics, which needs an OAuth grant this user may not have given. The response always includes total_posts_stored, so this also answers 'how many posts do I have?' and 'what was my first post?'. Use it for questions about their posting activity and performance — 'what did I post last week?', 'what's the average number of likes on my last 5 posts?', 'which recent post got the most comments?'. Compute averages and comparisons from the returned rows. like_count is the thumbs-up reaction alone; total_reaction_count is all reaction types combined. Pages: when has_more is true, call again with offset set to the next_offset from the response to continue through their history.",
"inputSchema": {
"properties": {
"limit": {
"description": "How many posts to return (default 20, max 200).",
"type": "integer"
},
"offset": {
"description": "How many posts to skip, for paging through more than one call can return (default 0).",
"type": "integer"
},
"sort": {
"description": "'newest' (default), 'oldest' for the start of their posting history, or 'top' for the most engagement first (total reactions, then comments, then shares).",
"enum": [
"newest",
"oldest",
"top"
],
"type": "string"
}
},
"type": "object"
},
"name": "get_my_linkedin_posts",
"outputSchema": null
},
{
"description": "The user's current YouSpot plan and credit balance, plus which plan they could move to. Call it before answering anything about pricing, plans, upgrading, credits or limits (brain cap, mailboxes, model). The response names the upgrade_plan value to emit; the card that renders from it does the purchase, so never say a payment happened.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "get_my_plan",
"outputSchema": null
},
{
"description": "The user's own tweets, newest first, from their connected X (Twitter) accounts — text, engagement metrics (likes, replies, retweets, impressions), date, and link. Reads the synced archive, so it's fast; a brand-new connection may not have synced yet. `query` filters tweet text. If it reports no account connected, give the user the link it returns.",
"inputSchema": {
"properties": {
"handle": {
"description": "One connected @handle to read. Omit to read all connected accounts.",
"type": "string"
},
"limit": {
"description": "Max tweets to return (default 20, max 100).",
"type": "integer"
},
"query": {
"description": "Case-insensitive substring to filter tweet text.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "get_my_tweets",
"outputSchema": null
},
{
"description": "Read one note from the user's Obsidian vault in full: its markdown, frontmatter, tags, the notes and brain objects its wikilinks point at, and the notes that link back to it. Identify it by object_id (from a search), by vault path ('Projects/Ada.md'), or by title. Use this whenever a search result looks like the answer — the search returns an excerpt, this returns the note. Follow the backlinks when the user asks how something connects to the rest of their thinking.",
"inputSchema": {
"properties": {
"object_id": {
"description": "Exact note id, e.g. note_aBc123.",
"type": "string"
},
"path": {
"description": "Vault path ('Meetings/2026-08-20 Ada.md'), filename, or note title.",
"type": "string"
},
"vault_id": {
"description": "Which vault to look in, when several are synced.",
"type": "string"
}
},
"type": "object"
},
"name": "get_obsidian_note",
"outputSchema": null
},
{
"description": "The saved messages of one Slack thread, oldest first: the parent and every reply the brain holds. Only threads from channels the user switched on are stored; an empty result means the thread was not captured, and the fix is enabling that channel on the Slack integrations page.",
"inputSchema": {
"properties": {
"channel_id": {
"description": "The channel id (C…/D…).",
"type": "string"
},
"thread_ts": {
"description": "The thread's parent ts (from a search result).",
"type": "string"
}
},
"required": [
"channel_id",
"thread_ts"
],
"type": "object"
},
"name": "get_slack_thread",
"outputSchema": null
},
{
"description": "Accounts the user follows on X (Twitter), from the synced follow graph — name, @handle, and bio. `query` filters by name, handle, or bio text ('who do I follow in AI?'). Reads the last sync, so a just-followed account may be missing; total_followed is the synced total. If it reports no account connected, give the user the link it returns.",
"inputSchema": {
"properties": {
"handle": {
"description": "One connected @handle whose follows to read. Omit for all connected accounts.",
"type": "string"
},
"limit": {
"description": "Max accounts to return (default 50, max 200).",
"type": "integer"
},
"query": {
"description": "Case-insensitive filter on name, handle, or bio.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "get_twitter_following",
"outputSchema": null
},
{
"description": "Live profile stats for the user's connected X (Twitter) accounts — name, @handle, follower count, following count, and total tweets, fresh from the X API. If it reports no account connected, give the user the link it returns.",
"inputSchema": {
"properties": {
"handle": {
"description": "One connected @handle. Omit for all connected accounts.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "get_twitter_profile",
"outputSchema": null
},
{
"description": "Import every contact or company from a file the user uploaded — a CSV or spreadsheet export, a .vcf of contacts, or a zip. Use this whenever they want more than a couple of records created from a file: it reads the whole file at once, so never read a contact list with read_file and create the records one at a time. Find the file first with search_graph_objects (type 'file') and pass its object_id, or pass part of the filename as name. Pass a description of what the file holds when the user gave one — it is what tells the column mapper that 'Ref' is a phone number.",
"inputSchema": {
"properties": {
"description": {
"description": "The user's own description of what the file holds.",
"type": "string"
},
"name": {
"description": "Part of the filename, when the object_id is unknown.",
"type": "string"
},
"object_id": {
"description": "The file's graph object_id (from search_graph_objects).",
"type": "string"
},
"target_type": {
"description": "What each row is. Defaults to contact.",
"enum": [
"contact",
"company"
],
"type": "string"
}
},
"type": "object"
},
"name": "import_contacts_from_file",
"outputSchema": null
},
{
"description": "People in the user's network who have moved to a different company since we last looked, newest first, with where they were and where they are now. Use when they ask who has changed jobs, who has moved recently, whether anything has changed at their contacts, or who is worth congratulating. Also the read behind a scheduled watcher: on a run with nothing new it says so and there is nothing to report. Reports a change of employer only, so a rewritten job title at the same company does not appear. NOT a list of who to contact, NOT the history with one person, NOT news about a company.",
"inputSchema": {
"properties": {
"days": {
"description": "Only moves noticed in the last N days. Default 90. Use 1 for a daily watcher.",
"type": "integer"
},
"limit": {
"description": "Max people (default 20, max 100).",
"type": "integer"
},
"refresh": {
"description": "Check the profiles for new moves before reading. Default true.",
"type": "boolean"
}
},
"type": "object"
},
"name": "job_changes",
"outputSchema": null
},
{
"description": "The user's LinkedIn post analytics from LinkedIn's own API (their connected account) — impressions, unique members reached, reactions, comments, and reshares. Use for questions like 'how many impressions did I get last month?' or 'how are my posts performing?'. Omit dates for lifetime totals; pass start_date/end_date for a window; set daily=true (with one specific metric) for a per-day series to describe trends. Numbers are live from LinkedIn, unlike get_my_linkedin_posts whose per-post counts come from a periodic sync.",
"inputSchema": {
"properties": {
"daily": {
"description": "Per-day time series instead of one total. Requires start_date and a specific metric (not 'all').",
"type": "boolean"
},
"end_date": {
"description": "Window end, YYYY-MM-DD (defaults to today).",
"type": "string"
},
"metric": {
"description": "Which metric ('all' fetches every metric — the default). LinkedIn's API takes one metric per call, so 'all' costs five calls.",
"enum": [
"all",
"impression",
"members_reached",
"reaction",
"comment",
"reshare"
],
"type": "string"
},
"start_date": {
"description": "Window start, YYYY-MM-DD. Omit for lifetime.",
"type": "string"
}
},
"type": "object"
},
"name": "linkedin_analytics",
"outputSchema": null
},
{
"description": "The user's own LinkedIn follower count over time, from readings we record about twice a day. Use it for every follower question: 'how many followers do I have?', 'how many did I gain this week?', 'how has my follower count changed since June?'. Returns the latest count, the count at the start of the window, the change, and a series with one point per day (per week for windows over 90 days). linkedin_analytics has no follower metric, so never say follower growth is unavailable without calling this first.",
"inputSchema": {
"properties": {
"days": {
"description": "How many days back to look (default 30, max 730).",
"type": "integer"
}
},
"type": "object"
},
"name": "linkedin_follower_history",
"outputSchema": null
},
{
"description": "List the images, emails, PDFs and documents generated in the user's active space, newest first, up to 50: the artifact_id, kind, title, status and brand. kind narrows it to one kind. Call it when the user asks what they have generated or refers to an earlier one.",
"inputSchema": {
"properties": {
"kind": {
"enum": [
"og_image",
"email",
"pdf",
"substack_post",
"markdown"
],
"type": "string"
}
},
"type": "object"
},
"name": "list_artifacts",
"outputSchema": null
},
{
"description": "List the brand kits in the user's active space: the name, domain, primary color, whether it was extracted from a website or entered by hand, whether it still needs their review, and which one artifacts render in when no kit is named. Call this before generating a social image, email or PDF for a brand other than the default, and when the user asks which brands they have set up. Returns fallback_if_omitted, which says what a generator uses when brand_kit_id is left out: the space default, the oldest kit, or the built-in YouSpot kit.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "list_brand_kits",
"outputSchema": null
},
{
"description": "List the labels in the user's connected Gmail mailboxes: system labels (INBOX, STARRED, ...) and the user's own labels, with their ids. Use it when the user refers to one of their labels by name.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of one connected mailbox. Omit to list labels for all connected mailboxes.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "list_gmail_labels",
"outputSchema": null
},
{
"description": "List the calendars in the user's connected Google account(s): name, id, whether it's the primary, and the user's access role. Use it to find a named calendar ('Family', 'Content schedule') before reading its events with get_calendar_events(calendar_id=…). If it says the account needs reconnecting, link the user to https://youspot.com/user/integrations/gmail.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of one connected Google account. Omit to list calendars for all connected accounts.",
"type": "string"
}
},
"required": [],
"type": "object"
},
"name": "list_google_calendars",
"outputSchema": null
},
{
"description": "List objects in the user's graph, newest first, with counts by type. The graph is their personal CRM's object store: person, company, hubspot_contact, linkedin_connection, file, fact, web_link, note, connected spaces, and more. Filter by type to browse one kind ('what files do I have?', 'list my facts'), or omit it to see what the graph holds overall. Page with offset to read past the newest results. For finding something by name, prefer search_graph_objects.",
"inputSchema": {
"properties": {
"limit": {
"description": "Max results (default 20, max 50).",
"type": "integer"
},
"offset": {
"description": "Skip this many results, for paging past the newest.",
"type": "integer"
},
"type": {
"description": "Only objects of this type (e.g. 'fact', 'web_link').",
"type": "string"
}
},
"type": "object"
},
"name": "list_graph_objects",
"outputSchema": null
},
{
"description": "What the user has connected, and what they could connect. Returns every integration available to this account with `connected` true/false, the accounts behind it, the tools it unlocks, and the URL to connect or manage it. Call this BEFORE telling anyone to connect anything, and before saying a source is unavailable: guessing is how the assistant has told people to connect accounts they already had. An integration missing from the list is not offered to this user at all, so do not suggest it. `suggested` is what is worth connecting next, best first, each with the payoff in the user's terms: use it when asked what would help, and lead with the first one rather than listing the shelf. Connecting is a browser grant: hand the user the URL, never claim to have done it.",
"inputSchema": {
"properties": {
"key": {
"description": "Ask about one integration only, e.g. 'linkedin', 'gmail', 'hubspot', 'slack', 'twitter', 'obsidian', 'sms'.",
"type": "string"
}
},
"type": "object"
},
"name": "list_integrations",
"outputSchema": null
},
{
"description": "Browse the user's synced Obsidian notes without a search term — most recently changed first, optionally within one vault, one folder, or one tag. Use it to answer what a folder holds, what they have written lately, or to show them what came across. When they are looking for a specific thing, search_obsidian_notes is the better tool.",
"inputSchema": {
"properties": {
"folder": {
"description": "Only notes under this vault folder, e.g. 'Daily'.",
"type": "string"
},
"limit": {
"description": "Max results (default 15, max 50).",
"type": "integer"
},
"tag": {
"description": "Only notes carrying this tag.",
"type": "string"
},
"vault_id": {
"description": "Only this vault (from list_obsidian_vaults).",
"type": "string"
}
},
"type": "object"
},
"name": "list_obsidian_notes",
"outputSchema": null
},
{
"description": "List the Obsidian vaults the user has synced into their Second Brain: note counts, the folders each vault holds, its most-used tags, and when it last synced. Call this before answering anything about their Obsidian setup — whether a vault is connected, how much of it is here, what it contains at the top level — rather than assuming either way. Returns an empty list with setup instructions when no vault is synced yet.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "list_obsidian_vaults",
"outputSchema": null
},
{
"description": "List the texts scheduled to be sent to the user's own phone that have not gone out yet, with the task_id needed to cancel each one.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "list_scheduled_texts",
"outputSchema": null
},
{
"description": "The Slack channels and DMs the user's brain knows about, per connected workspace, with whether each one is being saved (ingest) and how many messages are stored. Use it to resolve a channel name to its id before searching or posting.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "list_slack_channels",
"outputSchema": null
},
{
"description": "List the templates the user has saved from earlier drafts, newest first: the saved_template_id, name, kind and which manifest template it was made from. kind narrows it to one kind. Pass a saved_template_id to a generator as saved_template_id to generate from it again.",
"inputSchema": {
"properties": {
"kind": {
"enum": [
"og_image",
"email",
"pdf",
"substack_post",
"markdown"
],
"type": "string"
}
},
"type": "object"
},
"name": "list_templates",
"outputSchema": null
},
{
"description": "Given the author names from a page of posts, say which of them this user already knows. Ask in one call with every name, not one at a time. Each answer carries `standing`: 'dormant' means they know them and the correspondence stopped, which is the strongest reason to appear under a post; 'known' means they are still in touch; 'stranger' means they are not connected. Rank dormant first, known second, and keep a stranger only when the subject is squarely the user's own. `last_spoke` and `messages_exchanged` are there so you can say why this person is worth the reply.",
"inputSchema": {
"properties": {
"names": {
"description": "Author names exactly as the post search gave them.",
"items": {
"type": "string"
},
"type": "array"
}
},
"required": [
"names"
],
"type": "object"
},
"name": "match_my_network",
"outputSchema": null
},
{
"description": "Merge two duplicate records in the user's graph into one, person or company only. Every connection moves from the duplicate onto the kept record, fields the kept record lacks are copied over (never overwritten), and the duplicate is removed. Call with preview=true first and emit the merge_compare card it names: the card shows both records and merges when the user clicks, so never merge without an explicit yes. keep_id survives; merge_id goes. unmerge_graph_objects puts it back.",
"inputSchema": {
"properties": {
"keep_id": {
"description": "The record that survives (exact object_id).",
"type": "string"
},
"merge_id": {
"description": "The duplicate to fold in and delete.",
"type": "string"
},
"preview": {
"description": "Return what the merge would do without doing it. Call this first.",
"type": "boolean"
}
},
"required": [
"keep_id",
"merge_id"
],
"type": "object"
},
"name": "merge_graph_objects",
"outputSchema": null
},
{
"description": "The objects in the user's graph directly connected to BOTH of two given objects — mutual contacts between two people, shared people between two companies. Only deliberate relationships count (bulk-import and system-inferred edges are excluded). Returns an empty list when there are none — report that honestly.",
"inputSchema": {
"properties": {
"object_id_a": {
"description": "The first object (exact object_id).",
"type": "string"
},
"object_id_b": {
"description": "The second object (exact object_id).",
"type": "string"
}
},
"required": [
"object_id_a",
"object_id_b"
],
"type": "object"
},
"name": "mutual_connections",
"outputSchema": null
},
{
"description": "How this week is going on LinkedIn against the user's own post plan: the plan's subjects and whether each has a draft, what they posted this week and which plan subject each post was, the people they already know who reacted or commented (dormant first), and whether a nudge is due on Thursday. Use for 'how's my LinkedIn week going', 'did I post what I planned', 'who engaged with my post', 'who saw my post'. It never names strangers and has no impressions or follower counts; do not offer those. When plan is null, there is no plan for this week: offer to make one (the post-plan skill). When a subject has a draft_id, link it as [the draft](/graph/object/<draft_id> \"note\"). When plan is set, end with [See your week](/linkedin/manager), the page with the plan, its drafts, what went up and who noticed. switch says whether the daily LinkedIn manager is on, paused or off.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "my_linkedin_week",
"outputSchema": null
},
{
"description": "Work out what this user can speak to with authority, from what they have published, who is in their network, what they have been reading, and their profile — in that order of weight. Use this instead of asking them for keywords: they should never have to type a search query. Returns topics each carrying the source it came from and a short reason, plus `sentence`, one line naming what was picked and why, which you must show the user before anything you found. When `enough_to_go_on` is false there was too little to read and you should say so plainly and ask them what they care about, once — never guess.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "my_topics",
"outputSchema": null
},
{
"description": "Read an invoice PDF the user uploaded and return its fields: supplier, invoice number, dates, currency, subtotal, tax, total, PO number, payment terms, and every line item. Use it whenever someone asks what an invoice says, what they are being charged for, whether a bill adds up, or wants an invoice turned into data.\n\nTwo parts of the result matter more than the fields. `unreadable` names what could not be read off the document — those are null, not guessed, and you must not fill them in yourself. `checks` lists where the document disagrees with itself: lines that do not sum to the subtotal, a total that is not subtotal plus tax, a quantity times a price that is not the line amount. Report every check to the user in plain language; they are the reason to read an invoice with a tool rather than an eye.\n\nFind the file first with search_graph_objects (type 'file') and pass its object_id, or pass part of the filename as name.",
"inputSchema": {
"properties": {
"name": {
"description": "Part of the filename, when the object_id is unknown.",
"type": "string"
},
"object_id": {
"description": "The file's graph object_id.",
"type": "string"
}
},
"type": "object"
},
"name": "parse_invoice_pdf",
"outputSchema": null
},
{
"description": "Work out what generating would use, rendering nothing and spending no draft or credit. Give it the kind (og_image for any image, email or pdf for any document) and whatever the user has said so far; it answers with the template it would use and that template's fields with their defaults, which required fields are still missing, the image sizes, the brand kit it would resolve to and the other kits with their ids, the page, orientation and footer a PDF would take from the kit, the templates the user has saved, the free drafts left, the unlock cost, and ready. Call it once before generate_og_image, generate_email or generate_pdf, then generate in the same turn unless one open choice would change the result.",
"inputSchema": {
"properties": {
"align": {
"enum": [
"left",
"center",
"right"
],
"type": "string"
},
"appearance": {
"enum": [
"light",
"dark"
],
"type": "string"
},
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
},
"footer_text": {
"type": "string"
},
"header": {
"enum": [
"band",
"plain"
],
"type": "string"
},
"kind": {
"enum": [
"og_image",
"email",
"pdf",
"substack_post",
"markdown"
],
"type": "string"
},
"markdown": {
"type": "string"
},
"page": {
"enum": [
"letter",
"a4"
],
"type": "string"
},
"page_numbers": {
"enum": [
"on",
"off"
],
"type": "string"
},
"props": {
"additionalProperties": {
"type": "string"
},
"type": "object"
},
"saved_template_id": {
"description": "A saved_template_id from list_templates; its inputs seed the ones you pass.",
"type": "string"
},
"size": {
"description": "Where the image will be posted. Sizes: 'og' 1200x630 (The card X, LinkedIn, Slack and iMessage show under a link); 'square' 1080x1080 (An Instagram, LinkedIn or Facebook feed post); 'portrait' 1080x1350 (A taller Instagram or LinkedIn feed post); 'story' 1080x1920 (An Instagram or Facebook story, or a Reels cover); 'landscape' 1280x720 (A YouTube thumbnail or a 16:9 slide); 'facebook_cover' 1640x624 (A Facebook page or profile cover photo, shown at 820 by 312); 'linkedin_banner' 1584x396 (The background image on a LinkedIn profile); 'x_header' 1500x500 (The header image on an X profile). Left out it is 'og'.",
"enum": [
"og",
"square",
"portrait",
"story",
"landscape",
"facebook_cover",
"linkedin_banner",
"x_header"
],
"type": "string"
},
"subject": {
"description": "The email subject, if they gave one.",
"type": "string"
},
"template_id": {
"description": "The template the user named, if any.",
"type": "string"
},
"title": {
"description": "The PDF title, if they gave one.",
"type": "string"
}
},
"required": [
"kind"
],
"type": "object"
},
"name": "plan_generation",
"outputSchema": null
},
{
"description": "Permanently delete one object from the user's graph, along with every connection touching it. Hard delete, no undo — confirm with the user before calling, and only when they asked for the deletion. Prefer delete_graph_object, which is reversible and asks the user to confirm on a card; use this one only when they have said they want the data gone. To remove a single connection and keep both objects, use disconnect_graph_objects instead.",
"inputSchema": {
"properties": {
"object_id": {
"description": "The object to destroy (exact object_id).",
"type": "string"
}
},
"required": [
"object_id"
],
"type": "object"
},
"name": "purge_graph_object",
"outputSchema": null
},
{
"description": "Read back objects a skill wrote earlier, filtered precisely. Use this when you need to know whether something is already recorded rather than to find something by name: has this engagement already been flagged, was this client surfaced today, is there a plan for this week. Filters on type, on the source that wrote the row, on text within the name or description, and on a created-at window in days. Sorts newest, oldest or by name, and pages with offset. For a keyword or semantic hunt across the graph use search_graph_objects; for browsing a whole type use list_graph_objects.",
"inputSchema": {
"properties": {
"created_before_days": {
"description": "Only rows created more than N days ago.",
"type": "integer"
},
"created_within_days": {
"description": "Only rows created in the last N days. Use 1 for \"already done today\".",
"type": "integer"
},
"follow_up_due_by": {
"description": "Only rows whose follow-up date falls on or before this day, as YYYY-MM-DD. This is what 'what is due this week' reads. Use today's date for what is due or overdue.",
"type": "string"
},
"limit": {
"description": "Max results (default 20, max 50).",
"type": "integer"
},
"name_contains": {
"description": "Substring of the name, case-insensitive.",
"type": "string"
},
"offset": {
"description": "Skip this many results, for paging.",
"type": "integer"
},
"sort": {
"description": "Order of results. Default newest.",
"enum": [
"name",
"newest",
"oldest"
],
"type": "string"
},
"source": {
"description": "Only rows written by this source. Matches either the source recorded on the row or the marker a skill sets on what it writes, so 'capture_understand' and 'extension' both find what capture wrote.",
"type": "string"
},
"text_contains": {
"description": "Substring of the name or the description, case-insensitive.",
"type": "string"
},
"type": {
"description": "Only objects of this type (e.g. 'fact', 'note').",
"type": "string"
}
},
"type": "object"
},
"name": "query_graph_objects",
"outputSchema": null
},
{
"description": "People the user has not written to in a while, quietest first, with the date of the last thing they sent. Use when a skill needs to know who has gone quiet rather than to rank who is worth contacting: which clients have drifted, who is overdue a note, has anyone been silent since a given point. Judged on sent mail, so it measures what the user did rather than what arrived. `days` sets the line; the default is six months, which is the corpus's dormancy line rather than a tuned one.",
"inputSchema": {
"properties": {
"days": {
"description": "Quiet for at least this many days. Default 182.",
"type": "integer"
},
"limit": {
"description": "Max people (default 20, max 100).",
"type": "integer"
}
},
"type": "object"
},
"name": "quiet_contacts",
"outputSchema": null
},
{
"description": "Return a generated item itself, for showing it where a YouSpot link cannot be opened: a social image comes back as the PNG, a PDF as an image of each page, an email, document or Substack post as its text. Takes an artifact_id from a generator or list_artifacts. A draft comes back watermarked; the user unlocks the clean copy for a credit.",
"inputSchema": {
"properties": {
"artifact_id": {
"description": "An artifact_id from a generator or list_artifacts.",
"type": "string"
}
},
"required": [
"artifact_id"
],
"type": "object"
},
"name": "read_artifact",
"outputSchema": null
},
{
"description": "Read the content of a file the user uploaded, use this when the answer may live in a document in their Second Brain: schedules, itineraries, contracts, exports, scans. PDFs and images are returned as the actual document, so tables and scanned pages read correctly. Find the file first with search_graph_objects (type 'file') and pass its object_id, or pass part of the filename as name.",
"inputSchema": {
"properties": {
"name": {
"description": "Part of the filename, when the object_id is unknown.",
"type": "string"
},
"object_id": {
"description": "The file's graph object_id (from search_graph_objects).",
"type": "string"
}
},
"type": "object"
},
"name": "read_file",
"outputSchema": null
},
{
"description": "Read every new issue from the allowed publications into the brain, whole, so they can answer questions later. Returns what landed: `created` is new issues, `updated` is ones whose text changed, `unchanged` is ones already held, which is the normal case for a second run in a day. With no allowed sender it reads nothing and says so, which means the owner has not chosen yet — call find_my_newsletters and ask. `issues` names what arrived, newest first, so the summary can be written from it without another call.",
"inputSchema": {
"properties": {
"days": {
"description": "How far back to read. Default 2.",
"type": "integer"
}
},
"type": "object"
},
"name": "read_my_newsletters",
"outputSchema": null
},
{
"description": "Fetch and read the content of one public web page by URL — use when the user asks what a page or article says, or you need to read a prospect's or company's own site before a conversation. Reads the page as it renders in a real browser, so it works on JavaScript sites. Returns the page's readable text. Pass save=true to also keep the page in the user's graph as a web_link (searchable later); default is a one-off read that is not stored. Cannot read LinkedIn, social, or any sign-in-gated page — those are captured through the browser extension, and this tool says so rather than trying. Not for researching a company in general (that is research_company) or reading a file the user uploaded (that is read_file).",
"inputSchema": {
"properties": {
"save": {
"description": "Keep the page in the graph as a web_link for later search. Default false — a one-off read is not stored.",
"type": "boolean"
},
"url": {
"description": "The http(s) URL of the page to read.",
"type": "string"
}
},
"required": [
"url"
],
"type": "object"
},
"name": "read_web_page",
"outputSchema": null
},
{
"description": "Record one dated touchpoint with someone in the user's graph — an email exchanged, a call, a meeting, a LinkedIn touch, or a manually noted contact — so 'when did I last talk to them?' has an answer. Creates an interaction object connected to the person it happened with; get with_object_id from search_graph_objects. occurred_at is ISO 8601 ('2026-08-28T15:00:00Z') and may be in the future ('we're meeting next Tuesday'). direction is from the user's point of view: inbound means they reached out to the user.",
"inputSchema": {
"properties": {
"channel": {
"description": "How it happened.",
"enum": [
"email",
"call",
"meeting",
"linkedin",
"manual"
],
"type": "string"
},
"direction": {
"description": "'inbound' when they contacted the user, 'outbound' when the user reached out.",
"enum": [
"inbound",
"outbound"
],
"type": "string"
},
"occurred_at": {
"description": "When it happened (ISO 8601; future is fine).",
"type": "string"
},
"summary": {
"description": "One or two sentences on what happened.",
"type": "string"
},
"with_object_id": {
"description": "Who it happened with (their exact object_id).",
"type": "string"
}
},
"required": [
"with_object_id",
"occurred_at",
"channel",
"direction",
"summary"
],
"type": "object"
},
"name": "record_interaction",
"outputSchema": null
},
{
"description": "Who introduced the people in the user's graph, aggregated per introducer, so a skill can see which relationships actually produce work rather than which are warm. Returns each introducer with the people they introduced and how many of those became clients. Use for 'which relationships turn into work', 'who sends me business', 'what do my best clients have in common'. NOT a route to one stranger, which is find_paths, and not a warmth ranking, which is who has gone quiet.",
"inputSchema": {
"properties": {
"clients_only": {
"description": "Only count introductions that became clients, judged on a billed or worked_on edge. Default false, which counts all.",
"type": "boolean"
},
"limit": {
"description": "Max introducers (default 20, max 100).",
"type": "integer"
}
},
"type": "object"
},
"name": "referral_paths",
"outputSchema": null
},
{
"description": "Research one specific company in depth — the same engine behind the CompanyResearch.ai app. Takes a website domain (preferred) or a company name, and returns a profile: description, industry, size, revenue, funding history, founders, competitors, recent news, and answers to the user's saved research questions. Use this when the user asks to research, analyze, or get a briefing on a specific company. For discovering many companies by criteria, use find_companies instead; for a quick identity card, company_card markup is enough. The first run on an uncached company can take a while — that is normal.",
"inputSchema": {
"properties": {
"company": {
"description": "The company to research: a website domain (\"hubspot.com\", preferred) or a company name (\"HubSpot\").",
"type": "string"
}
},
"required": [
"company"
],
"type": "object"
},
"name": "research_company",
"outputSchema": null
},
{
"description": "Bring back objects the user deleted, up to 200 object_ids in one call: the undo for delete_graph_object and delete_selected_graph_objects. Only the user's own deleted objects come back. A record that was merged into another is not restored here; unmerge_graph_objects undoes a merge. Permanently purged objects are gone and cannot be restored.",
"inputSchema": {
"properties": {
"object_ids": {
"description": "The object_ids, at most 200.",
"items": {
"type": "string"
},
"type": "array"
}
},
"required": [
"object_ids"
],
"type": "object"
},
"name": "restore_graph_objects",
"outputSchema": null
},
{
"description": "Save a generated image, email or PDF as a template in the user's Second Brain, so the same inputs can be generated again from the generator or from chat. Takes the artifact_id a generator returned and a short name the user would recognise. Only the author's own draft can be saved. Returns the saved_template_id.",
"inputSchema": {
"properties": {
"artifact_id": {
"description": "An artifact_id from a generator or list_artifacts.",
"type": "string"
},
"name": {
"description": "A short name for the template.",
"type": "string"
}
},
"required": [
"artifact_id",
"name"
],
"type": "object"
},
"name": "save_as_template",
"outputSchema": null
},
{
"description": "Download a file from a public http(s) URL and store it in the user's Second Brain as a file object — use when the user shares a direct link to a PDF, image, spreadsheet, or other file and asks to save, download, or keep it. The saved file shows up with their uploads and can be read afterwards with read_file. Not for web pages (that is read_web_page with save=true) and not for files behind a sign-in. Files over 50MB are refused.",
"inputSchema": {
"properties": {
"filename": {
"description": "Name to store the file under. Default: the name the server or URL suggests.",
"type": "string"
},
"url": {
"description": "The http(s) URL of the file to download.",
"type": "string"
}
},
"required": [
"url"
],
"type": "object"
},
"name": "save_file_from_url",
"outputSchema": null
},
{
"description": "Search the user's own LinkedIn connections by name, company, or job title. Use this to answer questions like 'who do I know at Stripe?', 'which of my connections are founders?', or to look someone up by name. Returns matching people with their company, title, headline and location. Omit all filters to list the most recent connections. On a miss the response also reports how many connections the user has imported at all: if no_imported_data is set, their connections are simply not loaded — say that, and never conclude from an empty result that they don't know the person.",
"inputSchema": {
"properties": {
"company": {
"description": "Match against the company name.",
"type": "string"
},
"limit": {
"description": "Max results (default 20, max 50).",
"type": "integer"
},
"query": {
"description": "Match against the person's full name.",
"type": "string"
},
"title": {
"description": "Match against the person's job title.",
"type": "string"
}
},
"type": "object"
},
"name": "search_connections",
"outputSchema": null
},
{
"description": "Search the user's connected Gmail mailboxes and return matching messages, newest first: from, to, subject, date, and a short snippet of the body. `query` uses Gmail search syntax: 'in:sent to:[email protected]' for messages the user sent to someone, 'from:[email protected]' for messages they received, plus operators like subject:, newer_than:7d, and has:attachment. So 'show me the last 5 messages I sent to [email protected]' is query 'in:sent to:[email protected]' with max_results 5. Each result carries a `starred` flag; a message the user starred matters to them, so weight it accordingly; 'is:starred' finds starred mail directly. For 'how many' questions, use total_matches_estimate in the result (it is Gmail's estimate of ALL matches, beyond the messages returned). If it reports no Gmail account connected, give the user the link it returns. Rare header-only connections cannot run query search; the tool says so. Answer correspondence questions from the brain for those.",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of one connected mailbox to search. Omit to search all connected mailboxes.",
"type": "string"
},
"max_results": {
"description": "Max messages to return (default 10, max 100).",
"type": "integer"
},
"query": {
"description": "The search in Gmail query syntax, e.g. 'in:sent to:[email protected] newer_than:30d'.",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_gmail_messages",
"outputSchema": null
},
{
"description": "Find where something was said across the user's Granola meetings: a phrase, a name, a product, a number. Searches summaries and full transcripts of synced notes and returns each matching meeting with a short excerpt around the match. Use it for 'when did we discuss X' or 'what did she say about Y'; use get_granola_notes to browse by date.",
"inputSchema": {
"properties": {
"limit": {
"description": "Max meetings (default 10, max 50).",
"type": "integer"
},
"query": {
"description": "The phrase or name to find.",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_granola_transcripts",
"outputSchema": null
},
{
"description": "Search the user's graph by matching a term against object names and descriptions — plus semantic matching over text-bearing objects (notes, facts, posts, links, files, emails), so a search finds what the user means, not just exact words. Use this to find a specific thing they mentioned — a person, company, file, saved web link, or fact — when you don't have its object_id. Optionally restrict to one type. Returns matches with their object_id for follow-up with get_graph_object.",
"inputSchema": {
"properties": {
"limit": {
"description": "Max results (default 20, max 50).",
"type": "integer"
},
"query": {
"description": "Term to match against name and description.",
"type": "string"
},
"type": {
"description": "Only objects of this type (e.g. 'contact', 'fact').",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_graph_objects",
"outputSchema": null
},
{
"description": "Look up a person or company in the user's connected HubSpot CRM, live, by email address, domain, or name. Use this for 'what do I have on [email protected]', 'is gusto.com in the CRM', 'is Acme a customer', or 'do we have a contact named Jane Doe'. An email finds that contact and the company at its domain; a domain finds the company and the contacts at it; anything else is a name search over both. Returns the matching records with their CRM properties and a url to open each in HubSpot. lifecyclestage says where a record stands (subscriber, lead, marketingqualifiedlead, salesqualifiedlead, opportunity, customer, evangelist, other), so 'a customer' means lifecyclestage is customer. found=false with no errors means the CRM has no such record. For aggregate questions over many records use ask_about_hubspot_contacts or ask_about_hubspot_companies instead.",
"inputSchema": {
"properties": {
"object_type": {
"description": "Restrict to one record type. Default 'both'.",
"enum": [
"contacts",
"companies",
"both"
],
"type": "string"
},
"portal_id": {
"description": "A HubSpot portal (hub) id, when the user has more than one connected and named it.",
"type": "integer"
},
"query": {
"description": "An email address, a domain, or a person or company name.",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_hubspot_crm",
"outputSchema": null
},
{
"description": "Search the text of the user's imported LinkedIn messages (DMs), newest first. Filter by words in the message, by the person it was with, and by date. Use for 'who messaged me about hiring?', 'find the LinkedIn message where someone mentioned Shopify', 'what LinkedIn messages did I get last month?'. Returns snippets; read a whole thread with get_linkedin_conversation.",
"inputSchema": {
"properties": {
"limit": {
"description": "How many messages to return (default 20, max 50).",
"type": "integer"
},
"person": {
"description": "Only messages sent by or to this person (name, partial names match).",
"type": "string"
},
"query": {
"description": "Words or a phrase to find in the message text or subject.",
"type": "string"
},
"since": {
"description": "Only messages on or after this date, YYYY-MM-DD.",
"type": "string"
},
"until": {
"description": "Only messages before this date, YYYY-MM-DD.",
"type": "string"
}
},
"type": "object"
},
"name": "search_linkedin_messages",
"outputSchema": null
},
{
"description": "Search public LinkedIn posts by keywords. In chat, and for a watcher agent that collects posts, the matches are stored in the user's brain automatically, so do not re-save them with graph tools; an agent that only reads posts gets them back unstored, with no object ids. LinkedIn search matches loosely and returns posts that never say the keywords; those are verified away here and never stored, so what you get back has been checked, and discarded_count says how many were thrown out. The response splits posts into 'new' (never seen by this user before) and 'seen' (already stored on an earlier run). When running as a scheduled watcher, only report or email when 'new' is non-empty, and never include 'seen' posts. Link a post with [label](object:<object_id>) using the returned object ids. Pass found_by_object_id (your own agent node id, the id inside the [object:...] marker at the end of your instructions) so finds are filed under that agent.",
"inputSchema": {
"properties": {
"found_by_object_id": {
"description": "The searching agent's own object id, from the [object:...] marker. Omit in normal chat.",
"type": "string"
},
"query": {
"description": "Comma-separated keywords to search for.",
"type": "string"
},
"recency": {
"description": "How far back to search. Default Week.",
"enum": [
"Day",
"Week",
"Month",
"Quarter",
"HalfYear",
"Year"
],
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_linkedin_posts",
"outputSchema": null
},
{
"description": "Search the notes synced from the user's Obsidian vault, by keyword and by meaning, and get back where each one lives in the vault with an excerpt around the match. Use this when they ask what their notes say about something, or point at their vault ('in my notes', 'from my Obsidian'). Narrow with vault_id, folder (a vault path prefix like 'Meetings/2026'), or tag. Returns object_id and path for follow-up with get_obsidian_note, which returns the full note.",
"inputSchema": {
"properties": {
"folder": {
"description": "Only notes under this vault folder, e.g. 'Projects'.",
"type": "string"
},
"limit": {
"description": "Max results (default 15, max 50).",
"type": "integer"
},
"query": {
"description": "What to look for in the notes.",
"type": "string"
},
"tag": {
"description": "Only notes carrying this tag, e.g. 'meeting'.",
"type": "string"
},
"vault_id": {
"description": "Only this vault (from list_obsidian_vaults).",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_obsidian_notes",
"outputSchema": null
},
{
"description": "Search the Slack messages saved to the user's brain — by keyword and by meaning — newest first. Covers channels the user switched on and their DMs with YouSpot; nothing outside those. Optionally restrict to one channel (id or #name) or to messages since an ISO date. If it reports no Slack workspace connected, give the user the link it returns.",
"inputSchema": {
"properties": {
"channel": {
"description": "A channel id (C…) or name ('#general') to search within.",
"type": "string"
},
"limit": {
"description": "Max messages (default 10, max 50).",
"type": "integer"
},
"query": {
"description": "What to look for.",
"type": "string"
},
"since": {
"description": "Only messages sent on or after this ISO 8601 date.",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_slack_messages",
"outputSchema": null
},
{
"description": "Search recent public posts on X (Twitter) by keywords — the X API covers roughly the last week. Uses the user's connected X account; if none is connected, give the user the link it returns. Results are stored in the user's brain automatically — do not re-save them with graph tools. The response splits posts into 'new' (never seen by this user before) and 'seen' (already stored on an earlier run). When running as a scheduled watcher, only report or email when 'new' is non-empty, and never include 'seen' posts. Link a post with [label](object:<object_id>) using the returned object ids. Pass found_by_object_id (your own agent node id, the id inside the [object:...] marker at the end of your instructions) so finds are filed under that agent.",
"inputSchema": {
"properties": {
"found_by_object_id": {
"description": "The searching agent's own object id, from the [object:...] marker. Omit in normal chat.",
"type": "string"
},
"query": {
"description": "What to search for. X search syntax works: keywords, @mentions, \"exact phrases\", OR.",
"type": "string"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "search_tweets",
"outputSchema": null
},
{
"description": "Send an email to the signed-in user at their own account email address. Use this when the user asks to be sent something — 'email me this', 'send myself a reminder', 'send me that summary as an email'. The recipient is fixed to their own address and cannot be changed. To write an email to anyone else, use create_gmail_draft instead — it drafts in their Gmail without sending. Compose a short, specific subject line yourself if the user didn't give one.\n\nThe body is Markdown, rendered into the YouSpot email template before sending: '## ' subheadings, '- ' bullets, **bold**, > quotes and tables all work. Do not write HTML, and do not add a sign-off or a footer — the template supplies both.\n\nLINKS. Never write an absolute youspot.com URL; you do not reliably know them, and a wrong one reaches the reader as a dead link. Write one of these two forms instead and they are resolved for you:\n [Acme Corp](object:obj_4c1f88a2) — links to an object in the user's graph. The id must come from a graph tool result you actually ran; an id that is not theirs silently loses its link.\n [Which of these should I chase?](chat:Which of these prospects should I chase first?) — opens chat with that question ready to send.\nLink the objects you name, so the reader can go straight to what you are telling them about. End with one 'chat:' link offering the obvious next question — it is the cheapest way for them to act on what you found. The reader sends that question as their own, so never put their employer, title or role in it unless the About this user block states it; ask without naming a company rather than guess one.",
"inputSchema": {
"properties": {
"body": {
"description": "The body of the email, as Markdown. Use [label](object:<id>) to link a graph object and [label](chat:<question>) to link a ready-to-send chat question.",
"type": "string"
},
"subject": {
"description": "The email subject line.",
"type": "string"
}
},
"required": [
"subject",
"body"
],
"type": "object"
},
"name": "send_email",
"outputSchema": null
},
{
"description": "Post a message to a Slack channel or DM as YouSpot, optionally as a reply in a thread. Only channels the bot has been invited to work; use list_slack_channels to find ids. Write it the way you would write anything else: '## ' headings, '- ' bullets, **bold**, and [label](url) links all render, and Slack's own *bold* and <url|label> do too. Confirm with the user before posting anywhere others can see it.",
"inputSchema": {
"properties": {
"channel_id": {
"description": "Where to post (C…/D… id).",
"type": "string"
},
"team_id": {
"description": "The workspace, when the user has more than one.",
"type": "string"
},
"text": {
"description": "The message.",
"type": "string"
},
"thread_ts": {
"description": "Reply in this thread instead of the channel.",
"type": "string"
}
},
"required": [
"channel_id",
"text"
],
"type": "object"
},
"name": "send_slack_message",
"outputSchema": null
},
{
"description": "Send a short text message (iMessage/SMS) to the user's own phone, the number they verified on the iMessage or SMS integration. Sends right now by default; pass send_at to schedule it for later (a reminder for tomorrow morning, a nudge before a meeting). send_at must be ISO 8601 WITH the user's UTC offset, e.g. 2026-09-18T09:00:00-04:00: work out their timezone from the conversation or ask, never guess UTC. Scheduled texts can be listed with list_scheduled_texts and cancelled with cancel_scheduled_text. The recipient is always the user themself; no other number can be reached. If no verified number is on file, the response says so and carries the link to connect one. Keep messages short and concrete; there is a rate cap, so never use this for routine chatter.",
"inputSchema": {
"properties": {
"message": {
"description": "The text to send (max 1000 characters).",
"type": "string"
},
"send_at": {
"description": "When to send, ISO 8601 with a UTC offset (e.g. 2026-09-18T09:00:00-04:00), up to 90 days out. Omit to send immediately.",
"type": "string"
}
},
"required": [
"message"
],
"type": "object"
},
"name": "send_text_to_user",
"outputSchema": null
},
{
"description": "Make a brand kit the default for the user's active space, so social images, emails and PDFs render in it when no brand_kit_id is given.",
"inputSchema": {
"properties": {
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
}
},
"required": [
"brand_kit_id"
],
"type": "object"
},
"name": "set_default_brand_kit",
"outputSchema": null
},
{
"description": "Set a dated follow-up about an object in the user's graph — 'follow up with Jane in March'. Creates a follow-up fact carrying follow_up_at (ISO 8601, usually in the future) and an optional note, connected to the object it's about. Interim shape: there is no dated query tool yet, so to read follow-ups back ('what's due this week?'), list the user's fact objects and filter on json_data.follow_up_at yourself.",
"inputSchema": {
"properties": {
"about_object_id": {
"description": "What the follow-up is about (exact object_id).",
"type": "string"
},
"note": {
"description": "Optional reminder text.",
"type": "string"
},
"when": {
"description": "When to follow up (ISO 8601).",
"type": "string"
}
},
"required": [
"about_object_id",
"when"
],
"type": "object"
},
"name": "set_follow_up",
"outputSchema": null
},
{
"description": "Rename or re-describe an object in the user's graph, or set any of its type-specific fields: a contact's phone, email, headline or location, a company's funding stage, and so on. 'name' and 'description' work on every type (files included); other field names come from the type's field dictionary, which get_graph_object returns as 'editable_fields'. Read that first rather than guessing a name, because a name the dictionary does not have is skipped. Pass null to clear a field. Identify the object by object_id (search_graph_objects returns it).",
"inputSchema": {
"properties": {
"fields": {
"description": "Field name -> new value (e.g. {'name': 'Q3 deck'} or {'headline': 'CTO at Acme'}).",
"type": "object"
},
"object_id": {
"description": "The object to update (exact id).",
"type": "string"
}
},
"required": [
"object_id",
"fields"
],
"type": "object"
},
"name": "set_graph_object_fields",
"outputSchema": null
},
{
"description": "Turn the user's LinkedIn manager on, pause it, or say what it is set to. On, it runs daily: plans the week from their recent work when there is no plan, drafts the posts in it, checks what went up against it, nudges once on a quiet Thursday, and names people they know who engaged, by email and only when there is something to say. It never posts. Use for 'turn on the LinkedIn manager', 'pause my LinkedIn emails', 'is my LinkedIn manager on'. The same switch is on its card in Agents and on the Scheduled tab.",
"inputSchema": {
"properties": {
"action": {
"description": "turn_on, pause, or status to only read it.",
"enum": [
"turn_on",
"pause",
"status"
],
"type": "string"
}
},
"required": [
"action"
],
"type": "object"
},
"name": "set_linkedin_manager",
"outputSchema": null
},
{
"description": "Turn the recurring emails YouSpot itself sends the user off or back on, when they ask to stop getting one, unsubscribe, or resume it. The emails: exec_briefings is the daily 'Daily Briefing' built from their Second Brain; post_reports is the 'Your posts' section of that briefing (a LinkedIn post that is new or gaining traction); process_emails are the one-off notices when an import or sync finishes; agent_emails is the mail their cloud agents and LinkedIn or X watchers send (the agents keep running, only the email stops); tracker_updates is the email when a web page tracker finds a change. Pass only the settings they mean, false to stop. When they say 'this email' or 'the one I just got' without naming it, call with no arguments first: the result names the last email YouSpot sent them and the setting behind it, then call again with that setting false. This is for YouSpot's own mail only; for newsletters or senders in their Gmail use the Gmail tools. Confirm in plain words what is now off (or on) and that they can change it any time at the settings_url returned.",
"inputSchema": {
"properties": {
"agent_emails": {
"description": "Email from their cloud agents and watchers. false stops the email, not the agents.",
"type": "boolean"
},
"exec_briefings": {
"description": "The daily 'Daily Briefing' email. false stops it.",
"type": "boolean"
},
"post_reports": {
"description": "The 'Your posts' traction section of the Daily Briefing. false leaves it out.",
"type": "boolean"
},
"process_emails": {
"description": "The notices when an import or sync finishes. false stops them.",
"type": "boolean"
},
"tracker_updates": {
"description": "The email when a web page tracker finds a change. false stops it.",
"type": "boolean"
}
},
"type": "object"
},
"name": "set_notification_emails",
"outputSchema": null
},
{
"description": "Put a generated item behind a public link, so it can be posted, embedded in a page or opened by someone with no YouSpot account. Anyone holding the link can see it. revoke true takes an existing link away again. Returns the URL.",
"inputSchema": {
"properties": {
"artifact_id": {
"description": "An artifact_id from a generator or list_artifacts.",
"type": "string"
},
"revoke": {
"description": "Take an existing link away instead of making one.",
"type": "boolean"
}
},
"required": [
"artifact_id"
],
"type": "object"
},
"name": "share_artifact",
"outputSchema": null
},
{
"description": "The objects in the user's graph closest in MEANING to one object — nearest neighbours by stored embedding, so it finds related notes, facts, links, files, and posts even when no words match. Use it to browse outward from something search_graph_objects found. Only text-bearing objects carry embeddings (built in the background), so an empty result usually means the source has none yet.",
"inputSchema": {
"properties": {
"limit": {
"description": "Max results (default 10, max 50).",
"type": "integer"
},
"object_id": {
"description": "The object to find neighbours of (exact id).",
"type": "string"
},
"type": {
"description": "Only neighbours of this type (e.g. 'note').",
"type": "string"
}
},
"required": [
"object_id"
],
"type": "object"
},
"name": "similar_objects",
"outputSchema": null
},
{
"description": "Pull the user's newest Granola notes into their brain right away instead of waiting for the six-hourly sync. Queues the sync and returns; notes appear over the next minute or two. Say it was queued, not that it finished.",
"inputSchema": {
"properties": {},
"required": [],
"type": "object"
},
"name": "sync_granola_notes",
"outputSchema": null
},
{
"description": "The people the user has exchanged the most LinkedIn messages with, most-messaged first, with how many messages and when they last spoke. Use for 'who have I exchanged the most messages with?', 'who do I talk to most on LinkedIn?', and similar.",
"inputSchema": {
"properties": {
"limit": {
"description": "How many people to return (max 50).",
"type": "integer"
}
},
"type": "object"
},
"name": "top_message_correspondents",
"outputSchema": null
},
{
"description": "Undo a merge_graph_objects call: the record that was folded in comes back, its connections move off the kept record, the duplicate edges that were dropped are recreated, and the fields it contributed are removed from the kept record. Only fields the merge itself copied over, and only while they still hold what the merge put there, so a later edit survives. keep_id is the record that survived the merge.",
"inputSchema": {
"properties": {
"keep_id": {
"description": "The record that survived the merge.",
"type": "string"
},
"merged_id": {
"description": "The record that was folded into it.",
"type": "string"
}
},
"required": [
"keep_id",
"merged_id"
],
"type": "object"
},
"name": "unmerge_graph_objects",
"outputSchema": null
},
{
"description": "Change fields on a brand kit; fields left out keep their value. Set review_state 'confirmed' only after the user has looked at an imported kit and approved it. Returns the updated kit.",
"inputSchema": {
"properties": {
"brand_kit_id": {
"description": "A brand_kit_id from list_brand_kits.",
"type": "string"
},
"colors": {
"additionalProperties": false,
"description": "Hex colors (#rrggbb). Any left out keep their current value.",
"properties": {
"accent": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"background": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"border": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"card": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"foreground": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"muted_foreground": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"primary": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
},
"primary_foreground": {
"pattern": "^#[0-9a-fA-F]{6}$",
"type": "string"
}
},
"type": "object"
},
"dark_mode": {
"enum": [
"auto",
"off"
],
"type": "string"
},
"documents": {
"additionalProperties": false,
"description": "How this brand lays out PDFs. Any left out use the default.",
"properties": {
"accent": {
"enum": [
"band",
"line",
"none"
],
"type": "string"
},
"body_size": {
"enum": [
"small",
"regular",
"large"
],
"type": "string"
},
"density": {
"enum": [
"compact",
"comfortable",
"spacious"
],
"type": "string"
},
"footer_text": {
"description": "The footer line on every page. Empty string for no footer; left out it is the brand name.",
"type": "string"
},
"heading_scale": {
"enum": [
"small",
"regular",
"large"
],
"type": "string"
},
"orientation": {
"enum": [
"portrait",
"landscape"
],
"type": "string"
},
"page_numbers": {
"enum": [
"on",
"off"
],
"type": "string"
},
"page_size": {
"enum": [
"letter",
"a4"
],
"type": "string"
}
},
"type": "object"
},
"domain": {
"description": "The brand website host, like acme.com.",
"type": "string"
},
"fonts": {
"additionalProperties": false,
"properties": {
"body": {
"enum": [
"Archivo",
"Barlow",
"Bebas Neue",
"Bricolage Grotesque",
"Cormorant Garamond",
"Crimson Text",
"DM Sans",
"DM Serif Display",
"EB Garamond",
"Figtree",
"Fira Code",
"Fraunces",
"Geist",
"Georgia",
"IBM Plex Mono",
"IBM Plex Sans",
"Inter",
"JetBrains Mono",
"Karla",
"Lato",
"Libre Baskerville",
"Lora",
"Manrope",
"Merriweather",
"Montserrat",
"Mulish",
"Newsreader",
"Nunito",
"Open Sans",
"Oswald",
"Outfit",
"PT Serif",
"Playfair Display",
"Plus Jakarta Sans",
"Poppins",
"Raleway",
"Roboto",
"Rubik",
"Sora",
"Source Sans 3",
"Space Grotesk",
"Urbanist",
"Work Sans",
"system-ui"
],
"type": "string"
},
"heading": {
"enum": [
"Archivo",
"Barlow",
"Bebas Neue",
"Bricolage Grotesque",
"Cormorant Garamond",
"Crimson Text",
"DM Sans",
"DM Serif Display",
"EB Garamond",
"Figtree",
"Fira Code",
"Fraunces",
"Geist",
"Georgia",
"IBM Plex Mono",
"IBM Plex Sans",
"Inter",
"JetBrains Mono",
"Karla",
"Lato",
"Libre Baskerville",
"Lora",
"Manrope",
"Merriweather",
"Montserrat",
"Mulish",
"Newsreader",
"Nunito",
"Open Sans",
"Oswald",
"Outfit",
"PT Serif",
"Playfair Display",
"Plus Jakarta Sans",
"Poppins",
"Raleway",
"Roboto",
"Rubik",
"Sora",
"Source Sans 3",
"Space Grotesk",
"Urbanist",
"Work Sans",
"system-ui"
],
"type": "string"
}
},
"type": "object"
},
"name": {
"description": "The brand name.",
"type": "string"
},
"radius": {
"description": "Corner radius in px, rem or em, like 8px.",
"type": "string"
},
"review_state": {
"enum": [
"confirmed"
],
"type": "string"
}
},
"required": [
"brand_kit_id"
],
"type": "object"
},
"name": "update_brand_kit",
"outputSchema": null
},
{
"description": "Update one event on the user's connected Google or Outlook calendar: change its title (summary), description, location, or start/end times. Only the fields you pass change; everything else stays. Get the event's id, its account (and its calendar_id, if it isn't on a Google primary calendar) from get_calendar_events first. Use only when the user asked for the change; edits land on their real calendar immediately, and other attendees can see them. start/end are RFC3339 timestamps ('2026-08-25T19:00:00-04:00').",
"inputSchema": {
"properties": {
"account": {
"description": "Email address of the connected Google account or Outlook mailbox holding the event (the event's account). Omit to try every account with calendar editing.",
"type": "string"
},
"calendar_id": {
"description": "The Google calendar holding the event (from list_google_calendars). Omit for primary and for Outlook events.",
"type": "string"
},
"description": {
"description": "New description.",
"type": "string"
},
"end": {
"description": "New end, RFC3339 dateTime.",
"type": "string"
},
"event_id": {
"description": "The event id from get_calendar_events.",
"type": "string"
},
"location": {
"description": "New location.",
"type": "string"
},
"start": {
"description": "New start, RFC3339 dateTime.",
"type": "string"
},
"summary": {
"description": "New event title.",
"type": "string"
}
},
"required": [
"event_id"
],
"type": "object"
},
"name": "update_calendar_event",
"outputSchema": null
},
{
"description": "Update the user's own profile fields when they ask: timezone, name, headline, company website, LinkedIn URL or X handle. Only pass the fields they asked to change. timezone must be an IANA zone name: translate their words yourself ('ET', 'eastern time', 'Boston time' all mean America/New_York; 'PST' means America/Los_Angeles). Confirm what was set in your reply. Other facts about them go through update_profile_fields.",
"inputSchema": {
"properties": {
"first_name": {
"type": "string"
},
"headline": {
"description": "The one-liner under their name.",
"type": "string"
},
"last_name": {
"type": "string"
},
"linkedin_profile_url": {
"type": "string"
},
"timezone": {
"description": "IANA zone name, e.g. 'America/New_York'. Empty string clears it.",
"type": "string"
},
"twitter_username": {
"type": "string"
},
"website": {
"description": "Their company's domain, e.g. 'acme.com'.",
"type": "string"
}
},
"type": "object"
},
"name": "update_my_profile",
"outputSchema": null
},
{
"description": "Save facts the user tells you about themselves into their profile fields (birthday, city, role, company stage and the like). `values` maps field_id to the new value; an empty string clears a field. Call with an empty `values` to list every field with its id, type, allowed options and current value. For name, headline, timezone, website, LinkedIn URL or X handle use update_my_profile instead.",
"inputSchema": {
"properties": {
"values": {
"additionalProperties": {
"type": "string"
},
"description": "field_id -> value, e.g. {'birthday': '04-02'}.",
"type": "object"
}
},
"required": [
"values"
],
"type": "object"
},
"name": "update_profile_fields",
"outputSchema": null
},
{
"description": "Change a saved view in place: new source, title, spec_version or state. Pass only what changes. The artifact_id, its brain object and any share link stay the same.",
"inputSchema": {
"properties": {
"artifact_id": {
"description": "An artifact_id from generate_view or list_artifacts.",
"type": "string"
},
"source": {
"description": "The whole view in the view language, one statement per line.",
"type": "string"
},
"spec_version": {
"description": "The view library version the source was written against.",
"type": "string"
},
"state": {
"description": "The view's saved state values, keyed by name.",
"type": "object"
},
"title": {
"type": "string"
}
},
"required": [
"artifact_id"
],
"type": "object"
},
"name": "update_view",
"outputSchema": null
},
{
"description": "Every component and builtin a view can use (layout, charts, tables, Markdown, post cards, images and live cards), with its arguments, how Query, Mutation and Action work, the edit rules for a view patch, and the tools a Query may run for this user. Call it before writing any view source or view patch, including the source for generate_view or update_view. Takes no arguments.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "view_components",
"outputSchema": null
},
{
"description": "Search the open web and get back titles, URLs and snippets. Use when the answer is not in the user's own data and not about one named company: what a competitor is saying publicly, what is happening in a market, whether a claim checks out. For one company in depth use research_company; for the contents of a page you already have a URL for use read_web_page. Results are links and snippets, not the pages themselves.",
"inputSchema": {
"properties": {
"domain": {
"description": "Restrict to one site, e.g. 'techcrunch.com'. Omit to search everywhere.",
"type": "string"
},
"max_results": {
"description": "How many results (default 5, max 10).",
"type": "integer"
},
"query": {
"description": "What to search for, in plain words.",
"type": "string"
},
"since_days": {
"description": "Only results from the last N days. Use for \"what happened recently\" questions.",
"type": "integer"
}
},
"required": [
"query"
],
"type": "object"
},
"name": "web_search",
"outputSchema": null
},
{
"description": "What this user should deal with right now, computed from their sent mail, their calendar, their LinkedIn export and the follow-ups they set: follow-ups due this week or overdue, people who went quiet after real correspondence, people they are meeting this week, who they write to most, invitations nobody answered, and the shape of their network. Each item carries the reason and where the numbers came from. Call this for 'what needs my attention', 'who am I forgetting', 'who should I follow up with', 'what should I do today' and anything else that asks who to deal with without naming one person. Then show an attention_list card and never write the items out yourself. `readiness` says whether the mailbox has finished being read: when it is 'pending' or 'partial', say so rather than presenting a short list as the whole picture.",
"inputSchema": {
"properties": {
"kinds": {
"description": "Restrict to certain kinds. Omit for everything, which is almost always right.",
"items": {
"enum": [
"follow_up",
"dormant",
"meeting",
"frequent",
"invited",
"network",
"connect_more"
],
"type": "string"
},
"type": "array"
},
"limit": {
"description": "How many items to return (default 5, max 25).",
"type": "integer"
}
},
"required": [],
"type": "object"
},
"name": "what_needs_attention",
"outputSchema": null
}
]
}Verify it yourself
curl -s https://api.teppi.xyz/v1/evidence/sha256:ecbcad62aec585a9717010e5ad19d616aaa5d289369b940ef9c0132e4e90b965 | sha256sum