Arcade Raises $60M: A Developer's Guide to AI Agent Authorization Layers

Overview: The Secure Action Layer for AI Agents

Arcade has just closed a $60 million funding round, with the goal of becoming the Secure Action Layer for production-grade AI Agents. This milestone signals that the AI Agent infrastructure space is maturing rapidly — developer demand for Agent authorization and authentication has evolved from "good enough" to "must be secure and reliable."

Arcade AI Agent Authorization Developer Guide

This article takes a deep dive into what Arcade's MCP runtime actually does, how it differs from building your own OAuth solution, and when developers should consider using it.

Why Do AI Agents Need a Dedicated Authorization Layer?

The Limitations of Traditional OAuth

When an AI Agent needs to act on behalf of a user — sending emails, operating databases, calling third-party APIs — it must obtain proper authorization. The traditional approach is for developers to implement the OAuth flow themselves, but this presents several core challenges in Agent scenarios:

OAuth 2.0 is the most widely used authorization framework on the internet today, and its core design assumes a human user completing the authorization flow through a browser (e.g., clicking an "Allow" button). But AI Agents operate in a fundamentally different way: an Agent may run unattended in the background for hours or even days, with no ability to pop up a browser window for interactive user authorization. Furthermore, OAuth's standard flows — Authorization Code Flow, Client Credentials Flow, etc. — each have their own use cases, and different SaaS providers implement OAuth differently. Some use OAuth 2.0, others still rely on OAuth 1.0a, and some use custom API Key mechanisms. An Agent needs to handle all these heterogeneous authentication methods simultaneously, and the complexity grows exponentially.

Complex multi-service authorization management: A single Agent may need to access a dozen different services simultaneously, each with different OAuth implementation details
Token lifecycle management: Agents may run for extended periods and need to handle token refresh, expiration, and revocation
Granular permission control: Agents shouldn't have all of a user's permissions — fine-grained scope management is essential
Auditing and compliance: In production environments, every Agent action must be traceable

In production-grade Agent systems, token management is far more than just storing and using tokens. Access Tokens typically have short lifespans (e.g., 1 hour) and need to be periodically refreshed using Refresh Tokens. But Refresh Tokens themselves can also expire or be revoked, requiring a re-authorization flow. In multi-tenant scenarios, the system may manage tokens for thousands of users simultaneously, each potentially authorized across multiple services, forming a massive credential matrix. These tokens must be stored encrypted to prevent misuse if leaked. Race conditions must also be handled — when multiple Agent instances attempt to refresh the same token simultaneously, only one refresh request should succeed. Additionally, when a user revokes authorization on the third-party service side, the Agent system needs to detect this promptly and degrade gracefully, rather than throwing unhandled authentication errors at runtime.

The Role of the MCP Runtime

Arcade's core product is an MCP (Model Context Protocol) runtime that acts as a middleware layer between AI Agents and external services.

MCP is an open protocol introduced by Anthropic in late 2024, designed to standardize how large language models interact with external data sources and tools. Before MCP, every AI application had to write custom integration code for each external service, leading to massive duplication of effort and a fragmented ecosystem. MCP defines a unified client-server architecture: AI applications act as MCP clients to initiate requests, while external services expose capabilities through MCP servers (including tool invocation, resource access, and prompt templates). This standardization allows Agents to discover and invoke any compatible tool through a unified protocol, similar to how HTTP unified web communication. Arcade builds its MCP runtime on top of this, essentially adding authorization, security, and governance capabilities at the protocol layer.

This runtime is responsible for:

Unified authorization interface: Providing Agents with a standardized way to obtain authorization, abstracting away underlying OAuth implementation differences
Secure token custody: Centrally managing access credentials for all services — Agents never directly hold sensitive tokens
Operation auditing: Logging every external operation performed by an Agent, supporting retrospective review and compliance audits
Permission boundary enforcement: Ensuring Agents can only act within predefined permission scopes

Arcade vs. Building Your Own OAuth: A Technical Comparison

The Cost of Building In-House

If a team chooses to implement its own Agent authorization system, it typically needs to:

Write OAuth integration code for each third-party service
Build token storage and refresh mechanisms
Implement permission mapping and validation logic
Develop monitoring and auditing systems
Continuously maintain adaptations as service APIs change

For Agent systems integrating with five or more external services, this workload may require a dedicated engineering team with ongoing investment.

Arcade's Differentiated Value

Arcade abstracts these common capabilities into a platform service, allowing developers to focus solely on Agent business logic. Its core differentiators include:

Pre-built integrations: Authorization flows for common SaaS services are built in and ready to use out of the box
Declarative permissions: Agent permission boundaries are defined through configuration rather than code
Runtime enforcement: Even if an Agent's LLM generates an unauthorized command, the runtime layer intercepts it
Production-grade reliability: $60 million in funding means resources to guarantee SLAs and security audits

Declarative Permissions is a security design paradigm that contrasts with imperative permission checks. In the imperative model, developers must manually insert permission-checking logic at every critical code path, making it easy to miss spots. The declarative model defines Agent permission boundaries through configuration files or policies, with the runtime enforcing them automatically. This is similar to RBAC (Role-Based Access Control) in Kubernetes or IAM policies in AWS. Arcade's runtime enforcement mechanism is particularly critical: since LLM outputs are non-deterministic, an Agent may generate operation commands that exceed its intended permission scope (e.g., an Agent that should only read emails attempts to delete them). The runtime layer serves as the last line of defense, performing permission validation before commands are actually executed — implementing the zero-trust architecture principle of "never trust, always verify." This design shifts security responsibility from the application layer down to the infrastructure layer, significantly reducing security risks caused by LLM hallucinations or prompt injection attacks.

Use Cases and Recommendations

Scenarios Where Arcade Is a Good Fit

Production-grade Agents that need to integrate with multiple external services
Enterprise applications with strict security and compliance requirements
Teams that want to iterate quickly on Agent features rather than infrastructure
Industries like finance and healthcare that require fine-grained operation auditing

Scenarios Where You Might Not Need It

Simple Agents that only call a single API
Prototype projects for internal tools with lower security requirements
Organizations that already have mature OAuth infrastructure and teams capable of maintaining it

Industry Significance

Arcade's large funding round reflects a clear market signal: AI Agents are moving from demos to production, and one of the biggest bottlenecks in production environments is secure authorization.

Between 2023 and 2024, AI Agents underwent a critical transition from proof-of-concept to production deployment. Early Agent frameworks like LangChain and AutoGPT primarily focused on capability demonstration — enabling LLMs to call tools and decompose tasks. But when enterprises attempted to deploy these Agents to production, they discovered a series of issues that had been masked during the demo phase: secure authorization, error handling, cost control, observability, compliance auditing, and more. Gartner predicts that by 2028, 33% of enterprise software will incorporate Agentic AI components. This trend has spawned a new category of Agent infrastructure. Beyond Arcade's focus on the authorization layer, projects like LangSmith (observability), Guardrails AI (output safety), and CrewAI (multi-Agent orchestration) are each addressing different aspects of the production readiness challenge. Arcade's $60 million funding round is among the largest in this category, reflecting investors' strong emphasis on Agent security infrastructure.

As the MCP protocol gradually becomes the standard for Agent tool invocation, the infrastructure layer around MCP — authorization, monitoring, orchestration — will become the next competitive battleground.

For developers, understanding the design philosophy behind this type of middleware is valuable for building more secure and maintainable Agent systems, even if you don't use Arcade directly.