AI Agent Trust & Governance
Arcade vs Unified.to MCP: do both support OAuth Authorization Code + PKCE and IdP alignment?
8 min read
Most teams comparing Arcade and Unified.to in an MCP context are really asking one thing: which stack lets my agents act in real systems with user-specific OAuth, clean PKCE flows, and alignment to my identity provider—without me rebuilding auth from scratch?
Quick Answer: Arcade is built as an MCP runtime with first-class support for OAuth Authorization Code + PKCE, user-specific permissions, and alignment to your existing IdP. Unified.to is primarily an integration aggregation layer; it exposes unified APIs and handles OAuth for its own connectors, but it is not an MCP runtime and does not provide the same “agents act as the user” model, zero-token exposure to LLMs, or governance layer that Arcade gives you out of the box.
Frequently Asked Questions
Do Arcade and Unified.to both support OAuth Authorization Code + PKCE and IdP alignment?
Short Answer: Arcade is explicitly designed around OAuth Authorization Code + PKCE and IdP alignment for multi-user agents; Unified.to supports OAuth flows for its unified APIs but does not provide an MCP-native runtime or end‑to‑end IdP alignment in the same way Arcade does.
Expanded Explanation:
Arcade’s core promise is “secure agent authorization”: agents act with user-specific permissions, not shared service accounts. Under the hood, that means Authorization Code + PKCE flows, wired into your existing OAuth/IDP stack, and executed in a way that keeps tokens and secrets out of the model. You use SDK calls like client.auth.start(...) and wait_for_completion to kick off and complete user-specific auth, then call MCP tools (e.g., Google.SendEmail, Gmail.ListEmails) with those scoped credentials at runtime.
Unified.to, by contrast, is an API unification layer: it provides a consistent REST surface over many SaaS APIs and usually handles OAuth on behalf of its own “unified” connectors. That can be useful for traditional integrations, but it’s not designed as an MCP runtime with per-user authorization gates, IDP-rooted identities, and agent-safe token handling. You’d typically be bolting Unified.to behind your own auth layer, and you’d still need to solve the “agent acts as a specific user with governed permissions” problem yourself.
Key Takeaways:
- Arcade: MCP-native runtime with OAuth Authorization Code + PKCE, user-specific permissions, and tight IdP alignment.
- Unified.to: unified integration APIs with OAuth for its connectors, but not a full MCP runtime or “secure agent authorization” layer.
How does OAuth Authorization Code + PKCE actually work with Arcade’s MCP runtime?
Short Answer: You initiate an OAuth Authorization Code + PKCE flow through Arcade’s SDK, let the user approve access via your IdP/provider, and Arcade securely stores and refreshes tokens so MCP tools can act on behalf of that user at runtime.
Expanded Explanation:
In Arcade, OAuth is not an afterthought; it’s the backbone of how agents get permission to act. You start by calling something like:
from arcadepy import Arcade
client = Arcade()
user_id = "user@example.com"
auth_response = client.auth.start(user_id, "google")
# -> returns a URL your user visits to complete OAuth
Behind that simple call, Arcade runs an Authorization Code + PKCE flow with the provider (Google, Slack, GitHub, Salesforce, etc.). The user approves scopes (e.g., Gmail send, Calendar read), tokens are issued, and Arcade stores them in the runtime—not the LLM. Your agent then calls MCP tools (e.g., Google.CreateEvent) and Arcade injects the correct user-specific credentials at execution time.
Because the runtime enforces scopes and tracks which tools can use which tokens, you get consistent authorization semantics and an audit trail—without re-implementing OAuth, token refresh, or provider edge cases for each tool.
Steps:
- Start the auth flow: Call
client.auth.start(user_id, "google")(or similar) to generate an OAuth link with PKCE. - User approves access: The user completes OAuth via your IdP/provider; Arcade receives and stores the tokens.
- Agent uses tools: Your MCP agent calls tools like
Google.SendEmail; Arcade injects the correct scoped token and logs the action.
How is Arcade’s MCP runtime different from using Unified.to behind an agent?
Short Answer: Arcade is the runtime between AI and action with secure, user-specific authorization baked in; Unified.to is a unified API layer that you’d still have to wrap with your own auth, MCP tooling, and governance to make production agents viable.
Expanded Explanation:
When you hook an agent up to Arcade, you’re giving it:
- An MCP runtime that knows how to discover and call tools.
- Agent-optimized tools (not just thin API wrappers) with schemas designed for predictable tool use.
- An authorization system that ensures each tool call runs with the right user’s permissions.
Unified.to, by comparison, gives you a unified REST API over multiple providers. You still need to:
- Build MCP tools that call Unified.to APIs.
- Implement OAuth/PKCE handling in your app or gateway.
- Map real users in your IdP to Unified.to connections.
- Handle token refresh, revocation, error handling, and governance.
In other words, Unified.to can be one input into your tool implementation, but it doesn’t solve the runtime, authorization, and governance problems Arcade is built around.
Comparison Snapshot:
- Arcade: MCP runtime + secure agent authorization, OAuth Authorization Code + PKCE, user-specific permissions, zero token exposure to LLMs, audit logs, RBAC/SSO.
- Unified.to: Unified integration APIs with provider OAuth; you provide the MCP runtime, identity alignment, and governance yourself.
- Best for:
- Arcade: Teams shipping multi-user agents that must safely act across Gmail, Calendar, Slack, GitHub, Salesforce, HubSpot, Linear, etc.
- Unified.to: Teams standardizing raw API integrations who are comfortable owning the agent/runtime/auth layer.
How do I implement user-specific authorization for MCP agents with Arcade?
Short Answer: Use Arcade’s SDK to link your users (from your IdP or app) to provider accounts via OAuth, then let your agent call MCP tools that automatically run with those user-specific permissions.
Expanded Explanation:
Arcade assumes your agents are multi-user systems from day one. Instead of a shared service account, each human user authenticates their own Google, Slack, GitHub, or Salesforce account. Arcade’s runtime binds those tokens to a stable user identifier (often from your IdP), and tools execute with that user’s scopes only.
This gives you a clear, defensible story in security review: every tool call is tied to a real user, scopes are explicit, and there’s an audit trail. You don’t have to push tokens into prompts or build ad-hoc permission checks at the prompt level; authorization is enforced in code at the runtime.
What You Need:
- User identity source: Your IdP or app user IDs (SSO/SAML, OIDC, etc.) to identify who the agent is acting for.
- Arcade runtime + SDK: To start OAuth flows (
auth.start,wait_for_completion), manage tokens, and execute MCP tools with user-specific permissions.
Strategically, when should I choose Arcade’s MCP runtime over a unified API layer like Unified.to?
Short Answer: Choose Arcade when your primary goal is production-grade, multi-user agents that can safely take actions across business systems; use unified API layers only as a backend ingredient, not as a replacement for an MCP runtime with real authorization.
Expanded Explanation:
Most agent projects don’t fail because the LLM can’t reason; they fail because the “runtime between AI and action” is missing. Service-account bots, ad-hoc token hacks, and brittle API wrappers hit a wall in security review and in production (broken refresh tokens, unclear ownership, no audit trail).
Arcade is designed to clear that wall:
- Secure agent authorization: Agents act with user-specific permissions, mapped to your IdP, using OAuth Authorization Code + PKCE.
- Agent-optimized tools: MCP tools tuned for reliability and cost, not just thin wrappers over REST endpoints.
- Governance and deployment: Audit logs, RBAC, SSO/SAML, tenant isolation, and deployment options across cloud, VPC, on-prem, or air‑gapped.
Unified.to can simplify talking to a bunch of provider APIs, but it won’t give you that runtime, governance, or agent-safe authorization model. In practice, teams using Unified.to for agents still end up rebuilding much of what Arcade already provides.
Why It Matters:
- Impact on reliability: Arcade’s MCP runtime and tools reduce “it works in the demo” failures caused by missing tokens, wrong scopes, or service-account mismatches.
- Impact on security & adoption: User-specific permissions, IdP alignment, and zero token exposure to LLMs make it possible to deploy agents your security team will actually approve.
Quick Recap
Arcade and Unified.to solve different layers of the stack. Arcade is an MCP runtime built for secure, multi-user agents: it leans on OAuth Authorization Code + PKCE, ties actions back to real identities in your IdP, and keeps tokens out of the model while tools like Google.SendEmail and Gmail.ListEmails run with user-specific scopes. Unified.to is a unified integration API layer; it can simplify talking to third-party services but doesn’t replace an MCP-native runtime, authorization, and governance system. If your goal is production agents that safely move “from chat to action” across Gmail, Google Calendar, Slack, GitHub, Salesforce, HubSpot, and more, Arcade is designed for that exact problem.