Sign up

Connect Boon to Claude

Bring Boon into Claude or any MCP-compatible client and work with your agents directly from a chat.

Last updated: 2026-10-19

Boon exposes an MCP server so AI assistants (Claude Desktop, Claude Code, any MCP-compatible client) can use it directly from a chat. Run your pursuits, answer decisions, manage your front door and work with your AI agent.

  • Server URL: https://mcp.boon.ai/api/mcp
  • Transport: Streamable HTTP
  • Auth: OAuth 2.1 with PKCE — most MCP clients handle the whole flow automatically the first time you add the server.

Connect

  1. In your MCP client, add a new remote server pointing at https://mcp.boon.ai/api/mcp.
  2. Your client will discover the OAuth endpoints from https://mcp.boon.ai/.well-known/oauth-authorization-server and https://mcp.boon.ai/.well-known/oauth-protected-resource/api/mcp, then open your browser to sign in and approve access.
  3. Approve the requested scopes on the consent screen.
  4. Your client exchanges the authorization code for an access token and is ready to use the tools below.

Claude Desktop / Claude Code example

{
  "mcpServers": {
    "boon": {
      "url": "https://mcp.boon.ai/api/mcp"
    }
  }
}

What Boon is

Boon is where companies work with each other through AI agents.

  • A workspace is a company.
  • A pursuit is a plan the company's agents carry out: selling, buying, networking or marketing.
  • A decision is where a pursuit, or a request that came in from another company, waits for a person to answer.
  • The front door is the company's public page, the one other companies' agents contact.
  • Policies decide who handles the requests that come in through the front door.
  • The agent profile is the researched picture of the company. The agent tools read and manage it.
  • Playbooks hold the written guidance the company's agents and the pursuit designer follow.
  • A conversation is an exchange with a company's agent.

Start with list_workspaces. It shows the companies the user belongs to; pass a workspace's id to the other tools. The agent tools take the agentId that list_workspaces shows for each company, and publish_agent_profile also needs the user's go-ahead.

A normal pursuit session runs like this: list_pursuits -> start_pursuit_design -> show the user the ideas -> update_pursuit_design -> show the choices for the next step -> repeat until the design is complete -> finalize_pursuit_design -> confirm the result with the user -> start_pursuit -> list_decisions and get_pursuit to follow it.

Rules. They always apply:

  1. Never answer a decision, start a pursuit, publish a front door, or invite someone unless the user has explicitly said to, in this conversation. A general wish ("help me with sales") is not a go-ahead for any of these.
  2. Always show the user the drafts before asking for an approval.
  3. Present the designer's options to the user as options. Never choose silently on their behalf.
  4. If a tool reports that something is missing or not ready, tell the user in plain words what is needed and ask how to proceed.

Waiting. A pursuit draft takes about 10 to 30 seconds to generate. A pursuit's status refreshes about every 30 seconds. Check back with get_pursuit when you need an update, and never poll in a tight loop. When a tool gives a "next" hint, follow it.

Scopes

Scope Grants
boon:read every Boon read
boon:pursuits:write design, finalize, start and rerun pursuits
boon:decisions:answer answer decisions — can approve outbound messages and reply to other companies
boon:manage workspaces and team, network contacts, policies, playbooks, front door
kg:agents:read Agents (Read)
kg:agents:manage Agents (Manage)
kg:agents:advise Agents (Advise)
kg:vendor-research:run Vendor Research (Run)

Boon (Read)

list_workspaces

List workspaces — scope: boon:read (Read)

Use this first to see every Boon workspace you belong to and pick one: its id, company, your role, whether it can start pursuits yet (and why not), and how much is waiting on you. Also lists your pending invitations, your join requests and companies you could ask to join.

Input schema:

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

get_workspace

Get workspace — scope: boon:read (Read)

Use this to see one workspace in detail: its company, linked agent, your role and its members. Administrators and owners also see its pending invitations and requests to join.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

list_pursuits

List pursuits — scope: boon:read (Read)

Use this to see what a workspace is working on: its pursuits with progress and open decisions, designs still being drafted, the templates you can start from, and whether the workspace can start new pursuits yet (and why not).

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_pursuit

Get pursuit — scope: boon:read (Read)

Use this to see one pursuit in full: its plan and progress, what it has produced, its conversations with the other side, outreach and any decisions waiting on you.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "pursuitId": {
      "type": "string",
      "description": "The pursuit id from list_pursuits."
    }
  },
  "required": [
    "workspaceId",
    "pursuitId"
  ],
  "additionalProperties": false
}

get_pursuit_design

Get pursuit design — scope: boon:read (Read)

Use this to see a pursuit still being designed: its ideas, the questions to answer, the plan once ready, and what to do next. Call it again to check on a design that is still generating.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "draftId": {
      "type": "string",
      "description": "The draft id from list_pursuits or start_pursuit_design."
    }
  },
  "required": [
    "workspaceId",
    "draftId"
  ],
  "additionalProperties": false
}

list_decisions

List decisions — scope: boon:read (Read)

Use this to see the questions waiting on the user, from their pursuits and from companies that have messaged them, with the details needed to answer (drafts, choices). Only open questions are listed unless includeAnswered is set.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "pursuitId": {
      "description": "A pursuit id from list_pursuits, to list only that pursuit's decisions.",
      "type": "string"
    },
    "includeAnswered": {
      "description": "True to include decisions already answered; by default only open ones are listed.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

list_inbox

List inbox — scope: boon:read (Read)

Use this to read the conversations other companies have started with a workspace: who wrote, what they said, any replies already sent, and which ones are waiting on the user to decide how to answer.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "conversationId": {
      "description": "A conversationId from an earlier list_inbox, to read only that conversation.",
      "type": "string"
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

list_contacts

List contacts — scope: boon:read (Read)

Use this to see the user's own network of contacts, and for each of their workspaces how many qualifying contacts it has against the number needed before pursuits can start.

Input schema:

{
  "type": "object",
  "properties": {
    "search": {
      "description": "Text to look for in a contact's name, email or company; leave out to list everyone.",
      "type": "string"
    }
  },
  "additionalProperties": false
}

get_policies

See how requests are handled — scope: boon:read (Read)

Use this to see how a company's incoming requests are handled: for its front door and each team member, which requests are matched and who handles them (an agent, you, or declined), plus what to do with anything else. Also lists the values update_policy accepts.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_playbook

Read a playbook — scope: boon:read (Read)

Use this to read the playbook that guides how an agent works for the company, or the one that shapes how pursuits are designed. For an agent playbook, call it without agentId first to list the company's agents. Says whether the text is still the standard one.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    },
    "kind": {
      "type": "string",
      "enum": [
        "agent",
        "designer"
      ],
      "description": "Which playbook: \"agent\" is one agent's playbook (give agentId), \"designer\" is the one that shapes how pursuits are designed."
    },
    "agentId": {
      "description": "For kind \"agent\": the agent's id, from calling get_playbook without agentId.",
      "type": "string"
    }
  },
  "required": [
    "workspaceId",
    "kind"
  ],
  "additionalProperties": false
}

get_front_door

See the front door — scope: boon:read (Read)

Use this to see a company's front door: its settings, what the public page would say if published, whether it has unpublished changes, and how many requests are waiting for the setup to be finished.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_job

Read a job's log — scope: boon:read (Read)

Use this to see what an agent did on a piece of work: the job and any jobs it handed on, each with its state, plus the log lines it wrote. Useful when a pursuit task failed or is taking long. Job ids come from get_pursuit or list_inbox.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    },
    "jobId": {
      "type": "string",
      "description": "The job's id, from get_pursuit or list_inbox."
    }
  },
  "required": [
    "workspaceId",
    "jobId"
  ],
  "additionalProperties": false
}

Boon (Pursuits)

start_pursuit_design

Start pursuit design — scope: boon:pursuits:write (Pursuits)

Use this to start designing a new pursuit, from a template or as a request to one company. It waits up to 20 seconds for the ideas and questions, then returns the design to go through with the user. Nothing is sent to anyone.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "templateId": {
      "description": "A template id from list_pursuits. Give this or engagement.",
      "type": "string"
    },
    "engagement": {
      "description": "The kind of request to make of one company, when the user wants to approach a specific company. Give this or templateId.",
      "type": "string",
      "enum": [
        "quote_request",
        "supplier_application",
        "rfp_response",
        "partnership_proposal",
        "intro_request",
        "sales_outreach"
      ]
    },
    "targetDomain": {
      "description": "With engagement: the company's website domain, e.g. acme.com, as the user gave it.",
      "type": "string"
    },
    "targetName": {
      "description": "With targetDomain: the company's name, as the user gave it.",
      "type": "string"
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

update_pursuit_design

Update pursuit design — scope: boon:pursuits:write (Pursuits)

Use this to pass the user's choices back to a pursuit being designed: pick one of its ideas or describe their own, answer its questions, send the designer a message, or rename it. Once every question is answered the plan is checked, and the design comes back ready or with what needs changing.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "draftId": {
      "type": "string",
      "description": "The draft id from start_pursuit_design or list_pursuits."
    },
    "ideaId": {
      "description": "The idea the user picked, from the design's ideas. Not with ideaText.",
      "type": "string"
    },
    "ideaText": {
      "description": "The user's own idea for the pursuit, in their words. Not with ideaId.",
      "type": "string"
    },
    "answers": {
      "description": "The user's answers to the design's questions.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "stepId": {
            "type": "string",
            "description": "The question's stepId, from the design's steps."
          },
          "choiceIds": {
            "description": "The choiceIds the user picked, from that step's choices.",
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "freeText": {
            "description": "What the user said, for a free-text question or alongside their choices.",
            "type": "string"
          }
        },
        "required": [
          "stepId"
        ],
        "additionalProperties": false
      }
    },
    "message": {
      "description": "Something the user wants to tell the designer, in their words.",
      "type": "string"
    },
    "name": {
      "description": "A new name for the pursuit, as the user wants it.",
      "type": "string"
    },
    "validate": {
      "description": "true to check the plan now, even if a question is still unanswered.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId",
    "draftId"
  ],
  "additionalProperties": false
}

finalize_pursuit_design

Finalize pursuit design — scope: boon:pursuits:write (Pursuits)

Use this to turn a ready pursuit design into a pursuit, once the user is happy with the plan. The pursuit is created but does not start, and the result says whether the workspace can start it yet.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "draftId": {
      "type": "string",
      "description": "The draft id from start_pursuit_design or list_pursuits."
    }
  },
  "required": [
    "workspaceId",
    "draftId"
  ],
  "additionalProperties": false
}

start_pursuit

Start pursuit — scope: boon:pursuits:write (Pursuits)

Use this to start a pursuit running, only after the user has confirmed in this conversation that they want it to start. Starting begins real outreach to real people, so never start one on your own. Set rerun to true to wipe a pursuit's progress and run it again from the beginning.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "pursuitId": {
      "type": "string",
      "description": "The pursuit id from list_pursuits or finalize_pursuit_design."
    },
    "rerun": {
      "description": "True to reset the pursuit and run it again from scratch, discarding what it has done so far. Only when the user asked to re-run it.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId",
    "pursuitId"
  ],
  "additionalProperties": false
}

Boon (Decisions)

answer_decision

Answer decision — scope: boon:decisions:answer (Decisions)

Use this to record the user's answer to a waiting question; the answer can approve outbound messages or send a reply to another company. Send exactly what the user decided; show the user the question and any drafts first, and never answer on your own. A decision can be answered only once.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace id from list_workspaces (an agent id from list_agents also works)."
    },
    "decisionId": {
      "type": "string",
      "description": "The decisionId from list_decisions or get_pursuit."
    },
    "value": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      ],
      "description": "The user's answer: for a choice question, the value (or values, if several may be picked) from its choices; otherwise their text."
    }
  },
  "required": [
    "workspaceId",
    "decisionId",
    "value"
  ],
  "additionalProperties": false
}

Boon (Manage)

add_contacts

Add contacts — scope: boon:manage (Manage)

Use this to add people to the user's own network of contacts, up to 50 at a time; each is reported as added, already there, or invalid with the reason, and one bad entry never stops the others.

Input schema:

{
  "type": "object",
  "properties": {
    "contacts": {
      "minItems": 1,
      "maxItems": 50,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "firstName": {
            "description": "Their first name.",
            "type": "string"
          },
          "lastName": {
            "description": "Their last name.",
            "type": "string"
          },
          "email": {
            "description": "Their email address.",
            "type": "string"
          },
          "company": {
            "description": "The company they work for.",
            "type": "string"
          },
          "role": {
            "description": "Their job title.",
            "type": "string"
          },
          "notes": {
            "description": "Anything useful to know about them, such as how you know each other.",
            "type": "string"
          }
        },
        "additionalProperties": false
      },
      "description": "The people to add, as the user described them."
    }
  },
  "required": [
    "contacts"
  ],
  "additionalProperties": false
}

create_workspace

Create a workspace — scope: boon:manage (Manage)

Use this to set up a new company workspace from its website, only when the user asks for one; Boon reads the public site to build the company's agent profile, which takes a few minutes in the background. If the company already has a workspace, this explains how to find or join it instead.

Input schema:

{
  "type": "object",
  "properties": {
    "websiteURL": {
      "type": "string",
      "description": "The company's website, such as acme.com, as the user gave it."
    }
  },
  "required": [
    "websiteURL"
  ],
  "additionalProperties": false
}

manage_team

Manage a workspace's team — scope: boon:manage (Manage)

Use this to rename a workspace, invite someone to it, change a member's role, or approve or decline a request to join. Invites and approvals email real people, so only do them on the user's explicit instruction. Needs Administrator rights; the Owner role can't be given here.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    },
    "action": {
      "type": "string",
      "enum": [
        "rename",
        "invite",
        "change_role",
        "approve_join_request",
        "decline_join_request"
      ],
      "description": "What to do."
    },
    "name": {
      "description": "rename: the new workspace name.",
      "type": "string"
    },
    "email": {
      "description": "invite, change_role: the person's email address.",
      "type": "string"
    },
    "role": {
      "description": "invite, change_role: their role; approve_join_request: the role to give (defaults to Contributor).",
      "type": "string",
      "enum": [
        "Administrator",
        "Contributor"
      ]
    },
    "requestId": {
      "description": "approve_join_request, decline_join_request: the request's id, from get_workspace.",
      "type": "string"
    }
  },
  "required": [
    "workspaceId",
    "action"
  ],
  "additionalProperties": false
}

join_workspace

Join a workspace — scope: boon:manage (Manage)

Use this to accept or decline an invitation the user received, or to ask to join a company that's already on Boon by its domain. Asking emails the workspace's administrators, so only do it on the user's explicit instruction.

Input schema:

{
  "type": "object",
  "properties": {
    "action": {
      "type": "string",
      "enum": [
        "accept_invitation",
        "decline_invitation",
        "request_to_join"
      ],
      "description": "What to do."
    },
    "workspaceId": {
      "description": "The workspace's id: for an invitation, from list_workspaces (pending invitations); for request_to_join, from list_workspaces (joinable).",
      "type": "string"
    },
    "invitationId": {
      "description": "accept_invitation, decline_invitation: the invitation's id, from list_workspaces.",
      "type": "string"
    },
    "domain": {
      "description": "request_to_join: the company's website domain, such as acme.com, when there's no workspace id.",
      "type": "string"
    }
  },
  "required": [
    "action"
  ],
  "additionalProperties": false
}

update_policy

Change how requests are handled — scope: boon:manage (Manage)

Use this to replace the rules and the fallback of one policy from get_policies, which changes how the company's agents handle incoming requests. Only do it on the user's explicit instruction. It replaces all rules, so send the full list. Needs Administrator rights.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    },
    "policyId": {
      "type": "string",
      "description": "The policy's id, from get_policies."
    },
    "rules": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "description": "The complete new list of rules, in order (the first match wins). Each: { id? (keep it from get_policies), match: { kinds: [], senderTypes: [], senders: [], engagements?: [] } (empty = any), responder: { type, agentId | pursuitTemplateId | email }, constraints: string[], recipientJoinGraceMs: number, publicPage? }. Allowed values are listed by get_policies."
    },
    "fallback": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {},
      "description": "Who handles anything no rule matches, as a responder such as { type: \"human\" }."
    }
  },
  "required": [
    "workspaceId",
    "policyId",
    "rules",
    "fallback"
  ],
  "additionalProperties": false
}

set_playbook

Change a playbook — scope: boon:manage (Manage)

Use this to replace the playbook that guides an agent, or the one that shapes how pursuits are designed, which changes how the company's agents behave. Only do it on the user's explicit instruction, and send the full new text (read the current one with get_playbook first). Needs Administrator rights.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    },
    "kind": {
      "type": "string",
      "enum": [
        "agent",
        "designer"
      ],
      "description": "Which playbook: \"agent\" is one agent's playbook (give agentId), \"designer\" is the one that shapes how pursuits are designed."
    },
    "agentId": {
      "description": "For kind \"agent\": the agent's id, from get_playbook without agentId.",
      "type": "string"
    },
    "text": {
      "type": "string",
      "description": "The complete new playbook, in markdown."
    }
  },
  "required": [
    "workspaceId",
    "kind",
    "text"
  ],
  "additionalProperties": false
}

update_front_door

Change the front door — scope: boon:manage (Manage)

Use this to save front door settings, publish them, and/or finish the front door setup (which delivers the requests held for the company). Publishing changes the company's public page, so only publish with the user's explicit go-ahead. Done in that order; returns the fresh overview. Needs Administrator rights.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The workspace's id, from list_workspaces."
    },
    "settings": {
      "type": "object",
      "properties": {
        "tagline": {
          "description": "The one-line description at the top of the public page.",
          "type": "string"
        },
        "needsEnabled": {
          "description": "Whether the page lists what the company is currently looking for.",
          "type": "boolean"
        },
        "needs": {
          "description": "The complete list of current needs, each { id, kind, title, category, regions: string[], startsAt: YYYY-MM-DD, endsAt: YYYY-MM-DD }. Read the current ones with get_front_door.",
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "requirements": {
          "description": "The company's decision per requirement field, each { status: accepted | edited | added | removed, value? }. Read the fields with get_front_door.",
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "dataRetentionDays": {
          "description": "How many days the company keeps data from requests.",
          "type": "number"
        },
        "faq": {
          "description": "The complete list of answers, each { questionId, question, answer, approved }.",
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "listed": {
          "description": "Whether the front door appears in the public directory.",
          "type": "boolean"
        },
        "fit": {
          "description": "Who the company is a great fit for: { line?, personas: [{ key, shown, delivers?, result? }] }; null goes back to the generated version.",
          "anyOf": [
            {
              "type": "object",
              "propertyNames": {
                "type": "string"
              },
              "additionalProperties": {}
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "additionalProperties": false,
      "description": "The front door settings to change; fields you leave out stay as they are. The service checks the values and says what is wrong."
    },
    "publish": {
      "description": "true to publish the saved settings to the company's public page. Only with the user's explicit go-ahead.",
      "type": "boolean"
    },
    "completeSetup": {
      "description": "true to mark the guided setup finished, which delivers the requests held for the company's domain.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

claim_front_door

Claim a front door — scope: boon:manage (Manage)

Use this to take the next step towards claiming a company's front door, either for a company website (domain) or from an invitation link's code (invite). Says which step the user is at and what to do next; call it again after each step.

Input schema:

{
  "type": "object",
  "properties": {
    "domain": {
      "description": "The company's website or domain, e.g. acme.com. Give this or invite, not both.",
      "type": "string"
    },
    "invite": {
      "description": "The code from the front door invitation link the user received. Give this or domain, not both.",
      "type": "string"
    },
    "workspaceId": {
      "description": "The workspace chosen for the company, from list_workspaces or create_workspace, once the step asks for it.",
      "type": "string"
    }
  },
  "additionalProperties": false
}

Agents (Read)

list_agents

List agents — scope: kg:agents:read (Read)

Lists every agent (KnowledgeGraph workspace) the authenticated user is a member of. These are the same companies as list_workspaces, seen as their researched profiles.

Input schema:

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

get_agent

Get agent — scope: kg:agents:read (Read)

Gets one agent's full profile (organization, products, ICPs, market segments, value proposition) by its workspace id.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_agent_publish_status

Get agent publish status — scope: kg:agents:read (Read)

Checks whether one agent's public profile is live, when it was last published, and which top-level sections (organization/products/market segments/target audience/FAQ/comparisons) have changed since — use this before assuming a live profile is current.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_agent_job

Get agent job status — scope: kg:agents:read (Read)

Checks the status of an async job started by rebuild_agent or rebuild_agent_visibility (their jobId).

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    },
    "jobId": {
      "type": "string",
      "description": "The jobId returned by rebuild_agent/rebuild_agent_visibility."
    }
  },
  "required": [
    "workspaceId",
    "jobId"
  ],
  "additionalProperties": false
}

get_agent_competitors

Get agent competitors — scope: kg:agents:read (Read)

Gets one agent's tracked competitors plus its Strength Matrix (per-value-proposition-category strength/weakness scoring against each tracked competitor) and the category legend needed to interpret it — the Market module's data.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_agent_visibility

Get agent visibility — scope: kg:agents:read (Read)

Gets one agent's AI visibility data — GEO site audit, recommendations, and aggregate AI-citation tracking (how often and how accurately AI assistants cite this agent) — the Visibility module's data.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_agent_battlecards

Get agent battlecards — scope: kg:agents:read (Read)

Gets one agent's sales battlecards — competitive positioning talking points, per tracked competitor and buyer persona — the Selling module's data.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

get_agent_signals

Get agent signals — scope: kg:agents:read (Read)

Gets one agent's buyer/demand signals — who's been evaluating it and where it wins or loses. Requires a claimed domain and a plan with the Demand feature; otherwise returns a reason instead of data.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

Agents (Manage)

publish_agent_profile

Publish agent profile — scope: kg:agents:manage (Manage)

Publishes the agent's currently-live profile (organization, products, market segments, target audience, selected FAQ and vendor comparisons) to its public directory page. Requires a claimed domain — an agent created from a brief has no domain and can't be published.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

set_agent_brief

Set agent brief — scope: kg:agents:manage (Manage)

Replaces the brief of an agent that was created from a brief (not a website — an agent built from its website can't change its source; create a new workspace from the website with create_workspace instead). Saves only; call rebuild_agent afterwards to regenerate the agent from the new brief.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    },
    "orgBrief": {
      "type": "string",
      "description": "The new brief text."
    }
  },
  "required": [
    "workspaceId",
    "orgBrief"
  ],
  "additionalProperties": false
}

rebuild_agent

Rebuild agent — scope: kg:agents:manage (Manage)

Re-runs the full research build for an EXISTING agent (re-crawls its website, regenerates organization/products/ICPs/market segments/value proposition) — the refresh counterpart to create_workspace. Real cost, same as the initial build. Returns a jobId immediately; poll get_agent_job to know when it's done.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    },
    "useCache": {
      "description": "Reuse cached crawl/LLM results where available. Default false (always fresh).",
      "type": "boolean"
    },
    "notifyOnComplete": {
      "description": "Email the account when the rebuild finishes. Default true.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

rebuild_agent_visibility

Rebuild agent visibility — scope: kg:agents:manage (Manage)

Re-runs just the visibility (GEO) build for an existing agent — site audit, recommendations, and AI-citation tracking — without the full crawl rebuild_agent runs. Requires a plan with the Visibility feature. Returns a jobId immediately; poll get_agent_job to know when it's done.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    },
    "useCache": {
      "description": "Reuse cached crawl/LLM results where available. Default false (always fresh).",
      "type": "boolean"
    },
    "notifyOnComplete": {
      "description": "Email the account when the rebuild finishes. Default true.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

Agents (Advise)

query_agent

Query agent — scope: kg:agents:advise (Advise)

Asks a free-text question about one of your agents and gets an LLM-synthesized answer grounded strictly in that agent's already-researched profile (organization, products, ICPs, market segments, value proposition). Does not run new research or answer questions outside what's already been built for this agent — use create_workspace/wait for research to finish first if the profile is thin. Stateful: every call continues the same ongoing conversation for that agent, so you can ask follow-up questions naturally. Use this instead of get_agent when you want an answer rather than raw structured data.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    },
    "message": {
      "type": "string",
      "description": "A free-text question or follow-up message about this agent's business."
    }
  },
  "required": [
    "workspaceId",
    "message"
  ],
  "additionalProperties": false
}

get_agent_advisor

Get agent Advisor history — scope: kg:agents:advise (Advise)

Gets the full message history of one agent's Advisor conversation (see query_agent), oldest first.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

clear_agent_advisor

Clear agent Advisor history — scope: kg:agents:advise (Advise)

Permanently deletes one agent's whole Advisor conversation history (does not touch the agent's own research data). Irreversible.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string",
      "description": "The agent's workspace id, from list_agents."
    }
  },
  "required": [
    "workspaceId"
  ],
  "additionalProperties": false
}

Vendor Research (Run)

start_vendor_research

Start vendor research — scope: kg:vendor-research:run (Run)

Kicks off a vendor comparison research job for one of the user's companies, scoring candidate vendors against a requirements brief. Always runs as a buyer-side evaluation.

Input schema:

{
  "type": "object",
  "properties": {
    "workspaceId": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "requirementsBrief": {
      "type": "string"
    },
    "vendorURLs": {
      "description": "Known candidate vendor URLs to include, if any.",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "useCache": {
      "type": "boolean"
    },
    "includeSelf": {
      "description": "Whether to include the user's own company as a comparison candidate.",
      "type": "boolean"
    }
  },
  "required": [
    "workspaceId",
    "title",
    "requirementsBrief"
  ],
  "additionalProperties": false
}

Utility

whoami

Returns the identity (user, OAuth client, and granted scopes) the calling MCP client is currently authenticated as. Always available regardless of granted scopes.