Connect Your AI Agent to a CRM Pipeline in 5 Minutes

Every CRM integration tutorial I've read starts the same way: OAuth flow, access token management, pagination handling, webhook setup for real-time updates. By the time you've wired all of that together, you've written 200 lines of plumbing and haven't actually done anything with the data yet.

This tutorial takes a different approach. Supersonic exposes its entire CRM pipeline as MCP tools — named operations with JSON Schema parameters that any MCP-compatible agent can discover and call without middleware, without webhooks, without wrapper code. You give the agent a token and an endpoint. It figures out the rest.

Here's how to go from zero to a working agent integration in under five minutes.

What You'll Build

By the end of this tutorial, your agent will be able to:

• List deals from a live pipeline, filtered by stage
• Create a new contact with a single tool call
• Update a deal's pipeline stage and probability
• Log an activity note tied to a specific deal

No REST client. No request shaping. No response parsing beyond what the agent handles natively. That's the point of MCP.

Why MCP Instead of the REST API

Traditional CRM REST APIs are designed for humans building integrations. You get endpoints like GET /v2/deals?stage=negotiation&sort_by=updated_at&per_page=50. These work fine when you're writing code that owns the full request lifecycle — you know the parameters, you write the query, you parse the JSON.

An AI agent doesn't think this way. It thinks in operations: "find the stale deals in negotiation and log a follow-up activity for each one." Translating that intent into a sequence of correctly parameterized REST calls requires either careful prompt engineering or a wrapper layer you build and maintain.

MCP tools are that wrapper — but standardized, versioned, and self-describing. The agent discovers what operations exist, reads their schemas, and calls them correctly. You don't write the translation layer. The protocol handles it.

Step-by-Step: Connecting Your Agent

1. Get your API key

   Log into the Supersonic dashboard and generate an API key from the API Keys section. Keys have the prefix sk_ and are shown once at creation. Store it somewhere your agent can read at runtime — environment variable, secrets manager, or your agent framework's credential store.
2. Point your MCP client at the tool registry

   Supersonic's tool registry is a single endpoint:

GET https://supersonicos-2.polsia.app/api/mcp/tools
Authorization: Bearer sk_your_key_here

This returns the full schema for all 19 tools — names, descriptions, and JSON Schema parameter definitions. Any MCP-compatible client (Claude Desktop, LangChain, a custom agent loop) can fetch this once and cache it for the session.

If you're building a custom agent, the discovery step looks like this:

// Fetch available tools at agent startup
const resp = await fetch('https://supersonicos-2.polsia.app/api/mcp/tools', {
  headers: { 'Authorization': `Bearer ${process.env.CRM_API_KEY}` }
});
const { tools } = await resp.json();
// tools is an array of { name, description, parameters } objects
// Pass this to your LLM as the tool_choice or functions parameter

1. List deals from the pipeline

   The list_deals tool accepts optional filters for stage, value range, and sort order. Here's what a direct call looks like — the same call your agent will make when it decides to inspect the pipeline:

curl https://supersonicos-2.polsia.app/api/mcp/deals \
  -H "Authorization: Bearer sk_your_key_here" \
  -G --data-urlencode "stage=negotiation" \
     --data-urlencode "sort=updated"

Response: a clean JSON array of deal objects. No pagination envelope, no nested _links, no response metadata to strip. The agent gets the data it needs and reasons with it directly.

1. Create a contact

   This is where the tool schema approach pays off clearly. Here's the full create_contact schema your agent receives at discovery time:

{
  "name": "create_contact",
  "description": "Create a new contact record.",
  "parameters": {
    "type": "object",
    "properties": {
      "name":    { "type": "string", "description": "Full name (required)" },
      "email":   { "type": "string", "description": "Work email" },
      "company": { "type": "string", "description": "Company name" },
      "phone":   { "type": "string", "description": "Phone number" },
      "source":  { "type": "string", "description": "Lead source (e.g. inbound, outbound, referral)" },
      "notes":   { "type": "string", "description": "Freeform notes" }
    },
    "required": ["name"]
  }
}

The agent reads this schema and knows exactly how to call it. No documentation lookup. No parameter guessing. The LLM fills the fields it has, leaves optional ones blank, and sends the call. The API returns the new contact's id, which the agent can immediately use to link the contact to a deal.

1. Update a deal's pipeline stage

   Moving a deal forward after a call is a single update_deal call. The tool supports partial updates — you only send the fields that changed. The agent doesn't need to fetch the full deal record first.

// Agent-generated tool call (shown as JSON for clarity)
{
  "tool": "update_deal",
  "parameters": {
    "id": "deal_abc123",
    "stage": "proposal",
    "probability": 65,
    "notes": "Sent pricing deck. Follow up Thursday."
  }
}

Three fields updated. One tool call. The pipeline reflects reality immediately, without the agent needing to understand your CRM's internal data model or update sequence.

The Full Tool Surface

The 19 tools cover every operation you'd perform manually in a CRM UI:

You can browse all 19 schemas interactively at /mcp — tool names, full parameter definitions, and example responses.

Performance: Why It's Fast Enough for Agent Chains

When a human waits for a CRM response, 300ms is invisible. When an agent chains 8 tool calls to audit a pipeline, 300ms per call is 2.4 seconds of pure tool execution — before any LLM reasoning time. That's the budget you're working with, and it compounds with every additional workflow step.

Supersonic's MCP tools are tuned specifically for agent workloads:

Operation	Median latency	Why it's fast
list_deals	~18ms	B-tree index on stage + updated_at
create_contact	~12ms	Single INSERT, connection pooled
search_contacts	~22ms	GIN index on full-text search column
update_deal	~9ms	Partial update — only changed fields written
get_pipeline_summary	~31ms	Aggregation query over indexed columns

An 8-call agent workflow at these latencies takes roughly 160ms of tool execution time. The rest of your agent's latency budget goes to LLM reasoning — where it should go.

What Agents Actually Do With This

The integration itself is the easy part. Here's what becomes possible once it's in place:

Post-call logging in under 2 seconds. After a sales call, you dictate a 30-second voice note to your agent. It parses the note, calls create_activity with the outcome, updates the deal stage if you mentioned moving forward, and sets a follow-up date. The CRM reflects reality without you touching it.

Pipeline hygiene on a schedule. A nightly agent job calls get_pipeline_summary, finds deals stuck in the same stage for 14+ days, fetches their timelines with get_deal_timeline, logs stale-deal notes via create_activity, adjusts probabilities with update_deal, and sends you a summary. You wake up to a prioritized list, not a raw pipeline dump.

Inbound lead triage. A new form submission hits your backend. An agent calls search_contacts to check for existing records, creates a contact if none exists, creates a deal in the lead stage with create_deal, links the contact with link_contact_to_deal, and logs the inbound source as the first activity. Total: 4 tool calls, pipeline populated, no human involved.

---

Try It Live

The MCP explorer lets you browse all 19 tool schemas and send live requests. The agent demo shows a real agent working a pipeline — tool calls, reasoning, outputs — in real time.