Skip to main content
Profound MCP gives AI assistants tools to build, manage, and run Profound Agents directly from an MCP client. To connect your MCP client to the hosted server, refer to the Connection guides.
Learn more about Profound Agents in Profound Help Center.

​
How the tools work together

​
Run an Agent

1

Find an Agent

Ask which Agents exist. The assistant browses the organization’s Agents with list_agents, or pre-built templates with list_agent_definition_templates.
2

Inspect inputs

Ask what an Agent needs to run. The assistant reads its input_schema with get_agent before starting a run.
3

Run the Agent

Ask to run the Agent. The assistant starts the run with run_agent, passing inputs that match the Agent’s input_schema.
4

Check the results

Ask whether the run is done. The assistant checks the run state with get_agent_run.

​
Build an Agent

1

Open a build session

Ask to build an Agent. The assistant opens a build session with start_agent_build_session and includes the returned agent_build_session_id in every later build call, so the whole build attempt is tracked as one session.
2

Explore building blocks

The assistant assembles a workflow graph with list_agent_node_types and get_agent_node_schema, or starts from a template with list_agent_definition_templates.
3

Bind connected accounts

When the graph includes a node that runs on a connected account, the assistant fills that node’s integration_id with an ID from list_integrations.
4

Create or update a draft

The assistant previews the plan with create_agent_definition or update_agent_definition, and saves the draft once you confirm.
5

Validate

The assistant catches issues in the Agent’s structure early with validate_agent_definition and fixes them with update_agent_definition. This is a fast check before publishing the Agent.
6

Publish

Ask to make the Agent live. The assistant previews the publish plan with publish_agent_definition and applies it once you confirm.

​
Use natural language when working with Claude

If you’re using Claude as the client, you can prompt it in natural language to build Agents in one go, without making it step through various tools manually. Here’s an example prompt and an Agent structure Claude may produce with it:
An example diagram outlining the structure of an Agent Claude generated with the prompt above

​
Behavior and safety

Agents tools can create and update Agent definitions and start Agent runs. The create, update, and publish tools default to preview mode: the assistant receives a plan of the change first and applies it once you confirm.

​
Agents tools

Lists the Agents defined in your organization.Example prompts:
  • “Which Agents do we have published?”
  • “Show me our draft Agents.”
Inputs
Gets details of a specific Agent, including its input_schema. The assistant reads this before calling run_agent to confirm which inputs the Agent expects.Example prompts:
  • “What inputs does the article writer Agent need?”
  • “What does the weekly report Agent produce?”
Inputs
Starts an Agent run. Returns a run ID the assistant can use in get_agent_run.Example prompts:
  • “Run the article writer Agent on the topic ‘AI search trends’.”
  • “Kick off the weekly report Agent.”
InputsNotes:
  • Each key in inputs is a property ID from the Agent’s input_schema. The human-readable label for each property lives in that property’s title.
Gets the status and outputs of a previously started Agent run. The assistant checks this repeatedly until the run ends, whether it succeeds or fails.Example prompts:
  • “Is that Agent run finished yet?”
  • “What did the article writer Agent produce?”
Inputs
Opens an Agent build session, the first step before building or revising an Agent. The assistant calls it before any other build tool, then includes the returned agent_build_session_id in every later build call.Example prompts:
  • “Build an Agent that drafts AEO-optimized articles from our citation data.”
  • “Let’s rework the weekly report Agent.”
Inputs
Lists the node types available for building an Agent. Returns each type’s node_type identifier, display name, and a one-line description. The assistant calls this after opening a build session, when assembling a new Agent.Example prompts:
  • “What building blocks can the Agent use?”
  • “Is there a node that runs a web search?”
InputsNotes:
  • third_party nodes run on an account your organization connects, such as WordPress or Slack. platform_key nodes run on an external research vendor Profound has an agreement with, such as Exa or Perplexity, so there’s nothing for you to connect. native nodes are Profound’s own: the structural nodes, such as llm and code, and the profound_* nodes that read your Profound data.
Gets the configuration schema and examples for a specific node type. The assistant uses the returned schema to fill a node’s config correctly when building or editing an Agent.Example prompts:
  • “How is the LLM node configured?”
  • “What settings does the code node take?”
Inputs
Lists the integrations your organization has connected and made available to Agents. Returns an integration_id for each connection, which the assistant uses for integration nodes before publishing the Agent.Example prompts:
  • “Which integrations can I use in my Agent?”
  • “Is our WordPress connected, so the Agent can publish to it?”
InputsNotes:
  • The tool returns only active connections.
  • Each connection returns integration_id, provider, account, label, status, and level, which is org or user.
  • If you have several connections from the same integration provider (for example, two different WordPress sites for a blog and for documentation), the account field tells the connections apart.
  • Google Docs, Google Slides, and Google Sheets use the organization’s Google Drive connection, so a returned google_drive connection covers nodes from all three. Gmail and Google Search Console each have a connection of their own.
Browses the public catalog of pre-built Agent templates. Each template includes a plain-language goal, the inputs it needs, what it produces, and a skeleton workflow to use as a starting point. The assistant calls this before building a new Agent from scratch.Example prompts:
  • “What Agent templates can we start from?”
  • “Is there a template for a content refresh workflow?”
Inputs: none.
Reads an Agent’s definition graph in the same format that create_agent_definition and update_agent_definition accept. The assistant uses this when copying an existing Agent or inspecting a node type you want to replicate.Example prompts:
  • “Show me how the article writer Agent is built.”
  • “Copy the weekly report Agent as a starting point for a new one.”
Inputs
Creates a new draft Agent definition. The preview returns a plain-language plan and workflow diagram without saving anything, and the assistant saves the draft once you confirm.Example prompts:
  • “Save that workflow as a draft Agent.”
  • “Create the Agent we just designed.”
Inputs
Updates an existing draft Agent definition. The assistant uses this tool to fix validation issues after create_agent_definition or to iterate on a saved draft. Displays the preview first and applies it after you confirm.Example prompts:
  • “Fix the validation issues and update the draft.”
  • “Add a web search step to the draft Agent.”
Inputs
Checks whether a saved draft Agent definition is valid. Returns valid (boolean), issues (list of actionable errors), and, when the draft is publishable, the input_schema and output_schema the Agent exposes once live.Example prompts:
  • “Check whether the draft Agent is publishable.”
  • “Anything wrong with the Agent before we publish it?”
InputsNotes:
  • This is a fast check of the Agent’s structure before publishing. The publish_agent_definition tool runs the final validation, so a draft can pass this check and still be rejected at publish time.
  • If the check reveals any issues, the assistant fixes them with update_agent_definition.
Publishes an Agent definition so it goes live and is visible across the organization. Displays the preview first and applies it after you confirm.Example prompts:
  • “Publish the Agent so the team can use it.”
  • “Make the article writer Agent live.”
InputsNotes:
  • This tool runs the final validation, so an Agent draft with structural issues is rejected and stays a draft.
  • The assistant can catch issues earlier with validate_agent_definition.

​
Resources

Profound MCP provides reference material for Agents as read-only MCP resources.