Arcade made a bet early that the rest of the category is still catching up to — that agent tool calling is fundamentally an authorization problem, and that solving it properly through OAuth delegation rather than service accounts and bot tokens is what separates production agents from demos.
That bet was right. The question worth asking now is whether Arcade has built enough around that conviction to serve your use case, or whether a different tool fits better.
The problems that arrive in production once credentials are an afterthought are predictable:
This is the problem space Arcade is explicitly trying to own. For a deeper look at how tool calling auth patterns evolve in production, the tradeoffs are well documented.
Arcade was founded by executives from Okta — enterprise authorization done correctly is visible throughout the product.
Scalekit and Arcade share the same foundational conviction: auth and authz are the right starting point, not the last thing you add. The difference is where that conviction gets applied and at what scale.
Where Scalekit extends the Arcade model: Arcade solves per-user delegation elegantly. Scalekit solves that and the org-level authorization problem that emerges running agents across thousands of enterprise customers with different permission requirements. Per-connector scope configuration means you define, per integration, what each org's agents can do, enforced before the API is touched — an agent attempting an out-of-scope operation never reaches the API rather than receiving an error back from it.
Virtual MCP Servers take Arcade's per-user delegation principle a level further: a single MCP endpoint scoped to exactly the tools one agent role needs, with a fresh session token per run resolving to the right person's credentials. One definition serves every customer — the multi-tenant extension of what Arcade does well at the single-user level.
Where Arcade is genuinely ahead: the tool evaluation framework — CI/CD-style testing of tool-calling behavior before deployment — has no direct equivalent in Scalekit's current product. For teams whose primary concern is rigorously testing agent behavior pre-deployment rather than scaling authorization across many tenants, that's a real, specific strength worth weighing.
Observability: the full delegation chain — agent, connector, scope, tenant, action, result — logs natively and streams to your own SIEM or data warehouse, addressing directly the SIEM-exportable audit gap Arcade is still developing. This connects directly to the broader challenge of audit trails for agent auth in B2B SaaS.
Catalog and deployment: 500+ connectors, depth-first, well beyond Arcade's ~112. Deployment spans cloud-managed, VPC, and fully on-prem/air-gapped, where Arcade's runtime is closed-source with no self-hosting path.
Developer experience: native adapters for LangChain, Google ADK, Anthropic, OpenAI, Vercel AI SDK, Mastra, Claude Managed Agents, OpenClaw; per-user authenticated MCP URLs; custom tools, APIs, and MCP servers on the same auth/authz framework; one-command coding-agent plugin install via the Skills CLI.
Von's agents act inside Salesforce, Gong, HubSpot, Google Drive on behalf of individual sales team members:
"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 the Arcade model is right in principle but needs to scale across many enterprise customers with different permission requirements and audit demands.
Where it beats Arcade: roughly 10x the integration catalog (1,000+ vs. ~112) and dramatically faster time-to-first-tool-call.
Where Arcade wins: the auth model. Composio's is weaker — it works, but doesn't implement proper OAuth delegation the way Arcade does — and closed-source tools mean you're consuming, not owning, your tool definitions either way. No per-tenant authorization layer on either side, but Arcade's per-user delegation is still the more rigorous foundation.
Best fit: prototyping and single-tenant use cases where integration breadth matters more than auth model correctness. For a detailed breakdown, see the best Composio alternatives for AI agent tool calling.
Where it beats Arcade: observability — full request/response visibility, custom log messages, OpenTelemetry export, against Arcade's still-developing audit trail. Larger catalog too (700+ APIs vs. ~112), and fully open source where Arcade's runtime is closed.
Where Arcade wins: the auth model is a platform primitive in Arcade — verified delegation, checked permission scope — where Nango's authorization logic has to be hand-built into every TypeScript function you write.
Best fit: teams that want code-level ownership of their integration logic alongside a managed execution runtime, prioritizing observability over Arcade's auth rigor.
Where it beats Arcade: governance and DLP maturity — PII scanning, per-tool-pack rules, granular audit logs are all more developed than Arcade's current governance tooling, and Merge's compliance certifications (SOC 2, ISO, HIPAA, GDPR) are more extensive.
Where Arcade wins: the auth model, meaningfully. Merge's credential management was designed for developer-initiated integration code, not per-user OAuth delegation for agent-initiated actions — a structurally different (and for agents, weaker) foundation than what Arcade built from day one.
Best fit: teams already invested in the Merge ecosystem — not a natural fit for teams who chose Arcade specifically for its auth model. For a broader comparison, see best Merge.dev alternatives for AI agent connectivity.
Where it beats Arcade: catalog size (1,000+ vs. ~112) and a polished, white-labeled Connect Portal for end-user authorization that Arcade doesn't have an equivalent for.
Where Arcade wins: auth-model correctness. Paragon's reflects its embedded iPaaS heritage; per-tenant authz enforcement and audit infrastructure are both less developed than what Arcade built specifically around OAuth delegation.
Best fit: ISVs where integration breadth and embedded auth UX matter more than auth model correctness.
Teams evaluating Arcade alternatives are not questioning the auth-first premise — they're testing whether Arcade has built enough around that premise for their specific use case. The gaps that surface most often: catalog coverage that doesn't reach integration requirements, enterprise governance that isn't comprehensive enough for security reviews, deployment models that don't fit a data-residency requirement, or production confidence that comes from track record rather than architecture alone.
Understanding how tool calling auth changes when you move from single-tenant to multi-tenant is often the inflection point where teams realize the Arcade model alone isn't enough. The alternatives above each make a different trade-off around the same core problem. The right choice maps to your actual constraints in production, not the one that wins the feature checklist.
For teams thinking through the credential ownership question more deeply, who holds the token across agent tool-calling patterns is worth reading before making an architectural decision. And if you're evaluating the hidden costs of rolling your own solution, the hidden cost of building OAuth internally for AI agents covers what teams consistently underestimate.
