Ampersand 完成 1500 万美元 A 轮，为企业智能体做系统记录集成基础设施

Today, Ampersand announced that we’ve raised a $15 million Series A led by Bessemer Venture Partners, with Lauri Moore joining our board. This brings our total funding to $20M raised. We’re building integration infrastructure for enterprise agents. Here’s a little backstory on how we got here.

When I was CTO at Siftery, I learned a painful, vivid lesson about the integrations. Siftery was a SaaS spend management product for enterprises. Our customers all had these old ERPs and CRMs in place that had the data our product needed. So we had to integrate with these (legacy) systems of record. In my mind, there was the core product, which was my job, and then there were integrations, which I (mistakenly) thought didn’t need the same love as the core product.

A few months later, a thoughtful engineer I trusted enormously came to me late one evening and said: “Ayan, you’re not doing your job.” He was frustrated by the integrations mess we had created. He was frustrated that we didn’t understand NetSuite or Salesforce as well as we should have. Our product velocity was stalling; we were losing revenue because we lacked deep understanding of these complex systems of record.

This painful episode became the moment I got a little obsessed with deep integrations.

My co-founder Lauren witnessed the integration challenge through her experience building, launching, and growing Firebase Extensions, a platform of packaged solutions that developers primarily used to integrate their Firebase apps with third-party APIs. The product hit a nerve with developers (billions of executions per month). By the time Lauren and I met, we had a shared passion for this painful issue and a vision for what a great solution might look like, and what we could unlock for B2B software builders.

Enterprise software has a new user type: agents

It’s been 10 years since my own career-defining moment with integrations. Since then, integrations have only become more important and complex.

What changed? AI agents.

We’re in this fascinating moment right now where AI has the potential to transform the enterprise, but CTOs are still faced with the old problem of systems of record. Today it’s not just software calling other software; it’s agents taking action in these systems: investigating an overdue invoice, following up with an inbound lead, writing high-value information back to the system.

Suppose your AI startup is building the world's best “AI CFO” geared towards fast-growing AI infrastructure companies. The demo includes revenue forecasts and recommendations on which overdue accounts to pursue. You genuinely believe you are not selling just a tool; you are selling work, and your first customers love the positioning. In practice, the enterprise agent needs to find overdue invoices in NetSuite, check Salesforce for context on those customer relationships, and follow the company’s approval rules before sending payment reminders. Since every customer has different fields, approval rules, and workflows, each agent deployment ends up using a different setup.

This largely holds for most enterprise agent categories - whether you are building an AI accountant, an AI SDR, or an AI healthcare scribe, delivering on the promise of “we sell outcomes” means operating inside the systems of record your customers already use.

In 2026, if you’re building software for the Fortune 1000, you’ll be forced to deal with these systems with data/context gravity. You’ll see customer implementations held together with duct tape and prayers, powering a multi-billion-dollar business, and your sales team can’t close the deal without the ability to deliver a custom data model for a schema no one person fully understands. And you’re going to need a schema mapping that an agent of questionable intelligence can use to take action. Get ready…

What makes integrations so difficult: Tripartite Drift™️

While agents are the newest challenge with integrations, the old integration problems are still unsolved today. What makes them so uniquely challenging is what I call Tripartite Drift™️.

An integration is composed of three layers:

1. The provider layer: In the case of Salesforce or NetSuite, the provider layer includes multiple APIs, languages (APEX or SuiteScript, anyone?), SKUs, and customer auth & credentials.
2. The vendor layer: This is your own code. Often a collection of webhooks, workarounds, scripts, and customizations that build over time as you accommodate each new customer.
3. The customer layer: The customer’s own data model, permissions, and access, custom fields, and objects.

Change is happening constantly across all three layers.

APIs are being updated, credentials are expiring, your team is shipping new code, your customer’s Salesforce admin just left so the whole connection went down, and now they hired a new Salesforce admin who changed the name of the field your whole integration depends on. Every single one of these changes results in your team being pinged about an “integration error,” yes, even when it’s the customer’s fault.

Now, imagine this drift scaled across hundreds of customers using your integration.

Every customer is another implementation

In the children’s book (new dad here), If You Give a Mouse a Cookie, the author learns that offering a mouse a cookie leads to requests for milk, a straw, a napkin, help tidying up the mess, and eventually a place to take a nap, then a refreshing glass of milk on waking, then…you guessed it, a cookie to go with the milk. If Ampersand wrote a similar story it would be called, If You Build an Integration.

You will not build just one integration. Every Salesforce integration is unique. One tracks its sales process through standard objects; another uses custom objects, different permissions, and its own definition of a qualified opportunity.

The same problem appears in NetSuite approval workflows, SAP purchasing processes, industry-specific platforms, and decades-old custom applications. Some of this complexity is accidental. Some reflects differences in how businesses need to operate. Developers have to accommodate it all.

What we hear from customers, and what I experienced in the CTO role, is that it's not uncommon for an engineering team to spend 1-2 months configuring and understanding a single customer implementation of Salesforce. This means every time the CRO is saying: “Here is our path to hitting forecast this quarter”, the CTO sees the core product roadmap being delayed.

Many of the integration approaches on the market today are simply not built for the depth and complexity of systems of record. With these systems, there is no one size that will fit all customers. So instead, you must design for complexity from the very beginning, and that’s what we’ve done with Ampersand.

Today we are launching Ampersand as a complete deep integration solution for enterprise agents

Ampersand gives developers the building blocks to connect their products to their customers’ systems of record, adapt to each customer’s implementation, and keep those critical integrations and pipelines running.

We have spent three years building Ampersand alongside customers including 11x, Orb, Square, and several high-growth startups. That work has hardened the platform tremendously.

Ampersand has five primitives: Read, Subscribe, Search, Write, and Proxy. Together, they let agent developers sync customer data, respond to changes, search for specific information, make updates, and call underlying APIs directly. Developers define integrations in amp.yaml, including customer-specific objects, fields, and mappings. The runtime handles authentication, token refreshes, retries, backfills, monitoring, and the other machinery required to keep integrations running in production.

The core integration infrastructure is built and already having an enormous impact on our customers. Moving forward, we have three priorities for this funding round:

1. Expanding into ERPs and industry-specific systems of record Ampersand started by going very deep on CRMs. Last year we went deep into NetSuite, a uniquely challenging system of record, and helped companies like Square launch their NetSuite integration.

Next, we’re expanding our ERP integrations while also going deeper into systems of record across healthcare, insurance, logistics, financial services, and other verticals.

These systems are often harder to integrate with, have their own esoteric APIs/access patterns, permission models, scripting languages, workflows, data models, and decades of accumulated implementation decisions.

1. Building Andi, our AI integration agent The hardest part of an integration is rarely getting the first API call to work. It is understanding a customer’s implementation, mapping their data model to yours, configuring the integration correctly, diagnosing failures, validating workflows, adapting as things change, and keeping everything working over time.

We’ve released Andi (now in beta) to take on more of this work.

We want to give engineering teams the ability to build their own integration factory and customer data harness. Instead of asking an agent to generate one-off integration code, Andi operates against Ampersand’s deterministic infrastructure, primitives, configuration, observability, and validation. Your team defines how integrations should work; Andi helps implement and maintain them repeatedly across customers.

Our vision for Andi is not just faster integration development. It is a system where agents can do more of the implementation work while your engineering team retains a predictable, traceable, production-grade harness around what they build.

1. Growing our bench of the world’s best systems-of-record experts Sometimes you need someone who really, really knows NetSuite.

We’re building a forward-deployed team of experts who have spent years working inside systems like Salesforce, NetSuite, SAP, Workday, ServiceNow, Oracle, Epic, and the vertical systems that run entire industries and the broader economy.

They work alongside your team, the Ampersand platform, and Andi — from technical evaluation and solution architecture through implementation, rollout, and ongoing integration operations.

The goal is simple: when a customer shows up with a complicated implementation, you shouldn’t have to spend weeks or months deciphering that instance's nuances.

The CTO building an enterprise agent faces enormous pressure. You’re building toward the core agentic product vision while watching resources get pulled toward complex enterprise demands. I’ve been there, and I get it.

Our vision for Ampersand is to make these tradeoffs a little bit easier for CTOs to navigate. With this round of funding, we’re going to keep building deep integration infrastructure for systems of records, invest in agentic integration support, and expand our bench of human domain expertise.

If you share our excitement about taking a very messy, painful problem and making it trivial, then I hope you’ll consider trying Ampersand or joining us on this mission!