**TL;DR:** Ampersand is becoming agent-facing alongside its developer-focused, customizable, deep SaaS integration platform. We are introducing three pillars in this agentic transition - each designed to transform how the B2B SaaS interacts with its customers' GTM data forever: the [AI SDK](https://docs.withampersand.com/ai-sdk), [MCP server](https://docs.withampersand.com/mcp), and [Headless UI](https://docs.withampersand.com/headless), all of which are open source. Explore our documentation [here](https://docs.withampersand.com/) and the GitHub repo [here](https://github.com/amp-labs/ai). If you are curious to learn more, read on! --- Your shiny new AI agent drafts a near-perfect email, clicks “sync to CRM,” and face-plants on an unseen custom field. Now you are up at 2 AM reading Salesforce error logs... Again. Integration is every revenue-AI’s final boss, burning sprints on schema drift, rate-limit roulette, pagination edge cases, and the occasional token-refresh meltdown. Ampersand’s new [AI SDK](https://docs.withampersand.com/ai-sdk) and [MCP server](https://docs.withampersand.com/mcp) provide your AI agent with a direct connection to CRMs (e.g., Salesforce, HubSpot, Dynamics, ..), call recorders (e.g., Gong, Zoom, Fireflies, Fathom,..), marketing automation (e.g, Marketo, Braze,..), support and ticketing software (e.g., Zendesk, Intercom, JIRA, ..), outreach software (Outreach, Salesloft,..), billing and accounting software (Stripe, Netsuite in beta), and[ over 150 other GTM and revenue systems](https://www.withampersand.com/integrations), giving your agents access to real-time, mapped, and rate-limit aware systems in minutes, not sprints. In addition, you now have more ways to customize your end-user experiences and get to production faster with Ampersand’s [Headless UI](https://docs.withampersand.com/headless). Fully own the design and branding of your integrations while we take care of the heavy lifting. [**Ship product, not integration plumbing**](https://www.withampersand.com/how-it-works)**.** Leverage the power of Ampersand’s deep integration platform. # 1. The GTM-focused AI agent integration abyss Spin up a “smart” AI agent, and the first demo feels like magic. Point it at a live customer org, and the floor drops out. OAuth tokens expire, APIs throttle to 100 calls a day, cursors vanish mid-pagination, and every “standard” object is really _CustomObject_v3__c_ with seven underscore variants. Salesforce alone lets one object hold [up to 900 custom fields;](https://help.salesforce.com/s/articleView?id=xcloud.overview_limits_enterprise.htm&language=en_US) multiply that across HubSpot, Dynamics, Gong, Marketo, Zendesk, etc, and you’re staring at a combinatorial minefield. > Building custom integrations across multiple CRMs and the GTM stack felt like a game of whack-a-mole. When one issue was fixed, 3 others popped up. Ampersand solves that in a scalable way. > > Eric Engoron, Software Engineer, Scale @ Clay AI agents in the GTM stack are [doubling quarter over quarter](https://www.cbinsights.com/research/ai-agent-market-map/), each reinventing the same brittle integration plumbing. Release velocity tanks after sprints of integration maintenance, developer morale dips (I have been there myself!), and half of sprint planning becomes “who broke the CRM backfill this time?” That abyss, where clever prompts meet unforgiving enterprise APIs, is where most AI agents stall and die.  # 2. The USB-C moment for CRM+GTM data The Model Context Protocol (MCP) provided LLM agents with a typed interface that allows any external tool to be invoked without regard for language, SDK, or cloud. Powerful, but blank-slate: the typical MCP doesn't have enough contextual nuance to differentiate between a Deal and a Support Ticket, respect the quirky field mappings each customer invents, or invoke guardrails for rate limits or tenant walls. This turns your “smart” AI agent into a sloppy intern. **_Ampersand transforms that empty integration port into a_** [**_streamlined pipeline for the entire GTM stack_**](https://docs.withampersand.com/mcp) that your customers are already using. One verb set, one schema contract, fluent in 150-plus providers: Salesforce, HubSpot, Dynamics, Gong, Marketo, Zendesk, Amplitude, NetSuite (in alpha), and whatever acronym lands next. Behind the scenes, we translate every read, write, and webhook into the customer’s exact objects and custom fields, and throttle calls before a 429 ever hits your logs. Plug your GTM agent into Ampersand’s MCP endpoint, and that universal LLM port now speaks fluent GTM data - mapped, versioned, rate-limit-aware, and ready for production. [See how in the docs →](https://docs.withampersand.com/mcp) # 3. Inside the AI SDK That AI SDK surfaces **eight core verbs** enabling your agent with native “function calling” into 150+ GTM- and revenue-focused SaaS APIs: | **Tool** | **Description** | **Purpose** | | --- | --- | --- | | **createRecord** | Creates a new record in the connected SaaS platform | Create new records like contacts, deals, tickets, etc. | | **updateRecord** | Updates an existing record in the connected SaaS platform | Modify existing records with new data | | **sendReadRequest** | Makes authenticated GET API calls to the provider through Ampersand | Reading and searching records | | **sendRequest** | Makes authenticated API calls to the provider through Ampersand | Do any action that is available via the API | | **checkConnection** | Verifies if there is an active connection to the SaaS provider | Validate connection status before creating an installation | | **createInstallation** | Creates a new installation for a provider | Create an installation for an existing connection | | **checkInstallation** | Checks if there is an active installation for a provider | Verify installation status | | **startOAuth** | Returns URL for initiating OAuth flow for connecting to a provider | Authenticates a new user | Our initial focus for the AI SDK is on TypeScript developers working on top of Agent frameworks, such as [Mastra](https://mastra.ai) and[ Vercel AI SDK](https://ai-sdk.dev/docs/introduction). Below is a simple example of how to use the AI SDK tools by Ampersand in an agent built with Mastra. ```python import { Agent } from "@mastra/core/agent"; import { openai } from "@ai-sdk/openai"; import { createRecord, updateRecord } from "@amp-labs/ai/mastra"; // Mastra Agent with Mastra tools export const mastraToolsAgent: Agent = new Agent({ name: "Mastra Tools Agent", instructions: "You can use tools defined in Mastra.", model: openai("gpt-4o-mini"), tools: { createRecord, updateRecord, }, }); ``` Field mapping happens behind the curtain, test environments mirror prod, and deep syncs take eight lines instead of eight meetings. [Learn how to power up your agent with Ampersand’s AI SDK](https://docs.withampersand.com/ai-sdk). # 4. Meet the MCP Server [The Ampersand MCP server](https://docs.withampersand.com/mcp)'s real superpower is that it sits on top of Ampersand’s multi-tenancy platform, which keeps track of each customer’s unique SaaS set-up and the field-level permissions they give to your integration. Ampersand remembers all of your customers' preferences and mappings, so whether your customer logs "Lead Priority" in the stock Lead object, or hides it inside CustomObject__c, or renames it to Hot_Lead__c, as long as you call the Ampersand MCP server to update your customer's lead priority, we will update the field that their sales team actually uses.  Behind the scenes, the server refreshes OAuth tokens, stitches pagination, and handles API rate limits; a 429 response is retried after waiting the appropriate interval before your code even knows it happened. Learn more about the MCP and how you can [connect your agents to the 150+ connectors we offer here →](https://docs.withampersand.com/mcp) # 5. Meet the Headless UI: Smarts where it counts, styled how you want [Ampersand’s new Headless UI](https://docs.withampersand.com/headless) is the ultimate toolkit for building deeply integrated and beautifully branded experiences **_without reinventing the wheel_**. Keep your design system intact while cutting down time to launch, and our headless components do the heavy lifting behind the scenes. Whether you're shipping fast or scaling big, Ampersand’s Headless UI gives you full control with none of the scaffolding.  **One install, endless possibilities.** Get started with both headless and prebuilt components in one tidy package: ```python $ npm install @amp-labs/react # or $ yarn add @amp-labs/react ``` The headless library allows you to: - Handle the installation lifecycle: create, update, and delete - Implement custom UI components for object and field mapping - Maintain full control over the user experience. To build delightful integration management experiences for your customers, [get started with our docs → ](https://docs.withampersand.com/headless) # 6. Subscribe + AI SDK: Scalable real-time CRM sync in days, not quarters The AI SDK gives your agent lightning-fast pull access, but real “right-now” workflows demand a **push stream from the current Systems of Record**. Enter [**Subscribe Actions**](https://docs.withampersand.com/subscribe-actions). Ampersand handles the entire webhook maze - from event-bus setup and authentication to retries and replay IDs - then delivers a clean, mapped payload to your endpoint. Add a `subscribe` block to amp.yaml, and a contact update that fires off in Salesforce arrives at your server in under a second. The agent, powered by the AI SDK, enriches or transforms the data, then can call tools like updateRecord to write results back. > The real-time webhooks allow our phone agent, Julian, to focus solely on the exact Salesforce and HubSpot updates that our customers’ sales teams care about. It’s far more scalable than constant polling and expensive filtering. **Julian’s speed-to-lead time** **dropped from 1 minute to just 5 seconds** after a form submission, letting Julian call prospects before they even leave the website > > Muizz Matemilola, Engineering @ 11x Teams that once spent quarters, even years, wrestling with CDC, platform events, and custom mapping logic now **_stand up production-grade, bidirectional syncs in under a week_**. No rate-limit roulette, no cron hacks, just continuous, field-perfect data flow the revenue stack has wanted for a decade. That is not incremental, it rewrites the integration playbook. # 7. Depth over breadth Previous generation IPaaS MCPs (aka Zapier, Workato, n8n, etc) run MCP servers stuffed with tools like create_contact. How did we approach building the Ampersand MCP server? Ampersand gives you unlimited actions. Ampersand works with **every standard and custom object and field** that complex systems offer (and your customers use). | Feature | IPaaS MCP | **Ampersand AI SDK / MCP** | | --- | --- | --- | | Object coverage | Pre-canned Lead, Contact, Deal | Any standard **and** custom object | | Field handling | Fixed param lists | [Dynamically honors customer field mappings ](https://docs.withampersand.com/object-and-field-mapping) | | Versioning | None, silent breakage | Semantic versioning (/v1, /v2) | | Rate limits | DIY backoff or pray | Adaptive rate limiting, retry logic, exponential backoffs - infra that you dont have handroll and maintain | | Observability | Sparse logs if lucky | Full request/response logging | **Breadth looks flashy on a landing page; depth keeps PagerDuty quiet. Your GTM agent deserves the last column**. # 8. Let's build an Agent! Case Sherpa is an agent we built that listens for changes on the Case object in Salesforce and triages every case based on the severity classification provided by the user. The severity then gets written back to the same Case object. For cases classified as HIGH severity by the agent, a Slack alert is sent to the product team to resolve the situation with the customer. ```python import { Agent } from "@mastra/core/agent"; import { openai } from "@ai-sdk/openai"; import { updateRecordTool } from "@amp-labs/ai/mastra"; import { slackAlertTool, ...othertools } from "./tools" import { getEnvVars } from "./env.vars" const llm = openai("gpt-4o"); export const caseSherpaAgent = new Agent({ name: "Case Sherpa Agent", model: llm, tools: { ...othertools, updateRecordTool, slackAlertTool, // your custom Slack tool }, instructions: ` You are an expert case triage agent who analyzes Salesforce cases to determine their severity and provide concise summaries. Environment Configuration: ${getEnvVars()} When analyzing a case: 1. Carefully review both the Subject and Description 2. Classify severity based on these criteria: - High: Critical system issues, production outages, data loss, security incidents - Medium: Functional issues affecting multiple users, non-critical bugs - Low: Minor issues, documentation requests, single user problems 3. Generate a clear, one-sentence summary that captures: - The core issue - Impact scope (users/systems affected) - Any critical timing factors Guidelines: - Be objective in severity assessment - Focus on business impact - Consider urgency and scope - Keep summaries concise but informative - Highlight any security or data implications - Note time-sensitive aspects Your analysis will be used to: - Prioritize case handling - Alert relevant teams (via Slack for high-severity cases) - Create a quick understanding of the issue - Update the case record in Salesforce with the severity and summary - After analyzing the case, update the case object in Salesforce using the updateRecordTool with the following fields in the record object: - id - the id of the case object - AI_Severity_c__c - AI_Summary_c__c `, }); ``` **THAT'S IT!** - **No Salesforce boilerplate:** Ampersand’s Subscribe & Write actions hide the complexity of field-mapping, OAuth, and API version quirks. - **Single-file agent:** Mastra’s Agent primitives let you keep the entire workflow, classification, CRM write-back, and alerting, in **~50 lines of TypeScript.** - **Decision making remains with the agent:** Because writing is a tool call, now an agent can decide autonomously when to do it without this logic spilling over outside the agent loop! **See this in action:** The project is open-sourced here: [https://github.com/amp-labs/demo-case-sherpa](https://github.com/amp-labs/demo-case-sherpa) Now you have a production-ready "triage-bot” that goes from: A new Salesforce Case → LLM classification → CRM update → Slack alert, all without touching Apex, Flows, or custom middleware. With Ampersand, productionizing your CRM integrations takes 50 lines of code, not 50 (or 500) days. # 9. Roadmap and community Ampersand is the integration layer that **every enterprise AI agent needs**. We build in the open. Jump into [**Discord**](https://discord.gg/BWP4BpKHvf) to ask questions or share edge cases, file issues or PRs on [GitHub](https://github.com/amp-labs/ai), or email us at **chat@withampersand.com**. Your feedback shapes the roadmap, your code contributions land in production, and together we can enable every enterprise AI agent to interact with enterprise data without pain. (Because we know the pain.) We are built by developers for developers. Give your AI agent brain deep enterprise data superpowers! 
Back to articles