Merge earned its position. Thousands of B2B SaaS teams use Merge Unified API to stop reinventing HRIS, ATS, CRM, and ticketing integrations — one API, 220+ providers, maintained by someone else. The enterprise brand is real. The support is strong.
The question isn't whether Merge is good at what it was built for. It's whether what it was built for — normalized, deterministic API integration for SaaS products — is the right foundation for the agent use cases now landing on those same teams.
When you're building deterministic SaaS integrations, normalization is a feature. One schema for "Employee" across Workday, BambooHR, and Personio means you write integration logic once. That's the unified API value proposition and it's legitimate.
Agent tool calling has different requirements:
Scalekit was designed from the start around the agent execution model, not as an extension to an existing integration product — infrastructure specifically for agents acting on behalf of users in multi-tenant environments.
Where it directly answers Merge's architecture mismatch: connectors are built for LLM tool-calling semantics from the ground up, not retrofitted from a normalized schema — Salesforce concepts stay Salesforce concepts. Per-connector scope configuration means different orgs can have entirely different permission profiles for the same integration, enforced before the API is touched, where Merge applies identical behavior to every tenant by design.
Virtual MCP Servers extend scoping to the tool level — a single endpoint scoped to exactly the tools an agent role needs, not a connection's full catalog. A 40-tool connection can cost an agent roughly 8,000 tokens of context before real work starts; scoping to 5–10 tools cuts that by about 80%. One definition serves every customer, with a fresh session token resolving to the right person's credentials per run — the direct architectural answer to the per-tenant configuration gap Merge's normalization can't close.
Where the trade-off runs the other way: Merge's 220+ integrations are concentrated and deeply maintained in specific categories (HRIS, ATS, ticketing) where Merge has genuinely years of category-specific edge-case handling — ahead of Scalekit's 500+ broader but younger catalog in those particular categories specifically. And Merge's compliance certification breadth (HIPAA included) is more extensive than Scalekit's current SOC 2/ISO/GDPR posture, which matters if HIPAA is a hard requirement today.
Observability: the full delegation chain — agent, connector, scope, tenant, action, result — logs natively and is queryable inside the platform, with streaming to your own SIEM or data warehouse.
Deployment: cloud-managed, VPC, or fully on-prem/air-gapped — relevant for the same enterprise compliance conversations Merge's certifications are built to answer, with more deployment flexibility than Merge's managed-only model.
Developer experience: native adapters for LangChain, Google ADK, Anthropic, OpenAI, Vercel AI SDK, Mastra, Claude Managed Agents, and OpenClaw; per-user authenticated MCP URLs; one-command coding-agent plugin install via the Skills CLI.
Von, whose agents act across Salesforce, Gong, HubSpot, and Google Drive on behalf of individual sales team members, put it this way:
"Von touches identity in four places: user auth, embedded SSO, token store for integrations, and an AI tool calling proxy. Having all of that managed by Scalekit behind the scenes is what let us ship fast without stitching together parallel systems." — Venu Madhav Kattagoni, Head of Engineering, Von
Best fit: production-grade agent products where per-tenant authz, connector depth built for agents specifically, and deployment flexibility matter from the start — and HIPAA isn't an immediate hard requirement.
The most compelling alternative to Merge on customization and pricing. Nango is open source; tool definitions are TypeScript functions in your repo; pricing is usage-based rather than per-linked-account.
Where it beats Merge cleanly: observability (full request/response, OpenTelemetry — Merge's audit logs are governance-focused, not request-level) and pricing model — usage-based avoids the per-linked-account compounding that makes Merge expensive at real customer scale.
Where Merge still wins: compliance certification breadth (HIPAA specifically) and category depth in HRIS/ATS-style integrations where Merge has years of edge-case handling Nango's newer, broader catalog hasn't accumulated yet.
The trade-off: you're authoring integration logic rather than consuming pre-built tools. Higher ceiling; higher floor.
Best fit: teams that need to own their integration code, have high observability requirements, and want pricing that doesn't scale with customer count.
The agent-native option with the largest pre-built catalog: 1,000+ integrations, roughly 5x Merge's 220+, with framework adapters built for agents from the start rather than extended from a deterministic-sync architecture.
Where it beats Merge: architecture fit — Composio's tools don't carry Merge's normalization mismatch — and time-to-first-tool-call, measurable in minutes against Merge's more involved enterprise onboarding.
Where Merge wins decisively: governance maturity. Composio has no per-tenant configuration at all (Merge at least offers Agent Handler's DLP and rule enforcement, even if not per-tenant), and Composio's compliance certification (SOC 2 only) doesn't match Merge's SOC 2/ISO/HIPAA/GDPR breadth. No on-prem deployment option either, where Merge's enterprise-managed posture is at least battle-tested for regulated review.
Best fit: teams coming from Merge who want agent-native breadth and are willing to accept weaker governance in exchange for faster integration coverage.
The most principled auth-first option on this list — agents act as users through proper OAuth delegation, not service accounts, where Merge's credential management was designed for developer-initiated integration code, not agent-initiated actions.
Where it beats Merge: auth-model correctness, unambiguously, plus a CI/CD-style tool evaluation framework Merge Agent Handler has no equivalent for.
Where Merge wins: catalog size (220+ vs. Arcade's ~112 first-party integrations) in the categories Merge specializes in, and compliance certification breadth — Arcade's enterprise governance is still developing where Merge's is battle-tested.
Best fit: teams where auth model correctness is the primary driver and current integration requirements fit within Arcade's catalog. For a deeper look at the space, see best Arcade.dev alternatives for AI agent tool calling.
The closest architectural cousin to Merge on this list — both built serious integration infrastructure for consistent, deterministic SaaS connectivity, then extended into agents afterward.
Where it beats Merge: pricing at growth-stage customer counts tends to be more favorable than Merge's per-linked-account model, and the white-labeled Connect Portal is a stronger end-user connection experience than anything Merge ships.
Where Merge wins: governance and DLP maturity — Merge Agent Handler's PII scanning and per-tool-pack rules are more developed than Paragon's current agent-specific tooling, and Merge's compliance certifications (HIPAA specifically) go further.
Best fit: ISVs moving from Merge who need similar integration breadth with better pricing at scale, where end-user connection UX is a product requirement.
Teams evaluating Merge alternatives for agent use cases fall into two groups. The first is already on Merge, evaluating whether Agent Handler is the right path — for standard use cases that don't require per-tenant tool configuration or HIPAA-specific certification elsewhere, it's a reasonable extension. For anything requiring deeper authz control or agent-native architecture, it's worth evaluating from scratch.
The second group is building agent products and considering Merge for the enterprise brand and compliance story. The compliance story is real. The question is whether the unified API abstraction serves your agent use case — or whether you're optimizing for a familiar brand when the architecture isn't the right fit. Does your agent need to act on behalf of users with their own credentials, scoped to their permissions, with audit evidence per action, in a deployment model more flexible than managed-SaaS-only? If yes, that should drive the selection — not which product has the longest compliance certification list.
Understanding access control for multi-tenant AI agents is foundational to making the right call here. And if you're evaluating the broader authorization model, it's worth understanding agent tool calling auth patterns and anti-patterns before committing to any platform. For teams thinking about how auth evolves as you grow, how tool calling auth changes when you move from single-tenant to multi-tenant is directly relevant.
