If you've been using Cursor, Claude Desktop*, VS Code, or any MCP-compatible client, you've probably experienced the same frustration: your agent is brilliant at reasoning through workflows, but the moment it needs to actually do something across your tools, you're back to juggling configurations for each individual tool, debugging auth flows, and troubleshooting why the setup that worked yesterday doesn't work today.
Those days are over. With the launch of Arcade MCP Gateways, your MCP client of choice can now instantly connect to Arcade’s catalog of best-in-class tools as a single collection so you get agents that can actually take actions with full authorization and better accuracy, for any use case you need. As a single URL, your agents can access a curated set of use case specific tools, work across any MCP client, and be shared with your entire team in seconds.
The Pain You Already Know
Every developer who's tried to build real workflows with MCP tools has hit the same walls:
Fragmented tooling. You need GitHub, Linear, Slack, and maybe your CRM. That's four different MCP servers, each with its own configuration, its own auth flow, its own quirks. Some are official, some are community-maintained, some break when you look at them wrong.
IDE lock-in. You painstakingly configure everything in Cursor. Then you want to try Claude Desktop* or the new VS Code MCP support. Time to start from scratch.
Team friction. Your workflow is finally working. Now you need to onboard three teammates. That means writing documentation, walking them through auth, debugging why it works on your machine but not theirs.
Zero visibility. Something went wrong. Which tool failed? What permissions are missing? You're flying blind.
These aren't edge cases. This is the default experience for anyone trying to build agent-driven workflows today.
What MCP Gateways Now Enable
An Arcade MCP Gateway is a single URL that exposes a curated set of tools through one consistent interface. What does this unlock?
Access the largest catalog of high-quality tools
Most MCP servers you'll find are minimal wrappers around REST APIs. They expose raw endpoints, return inconsistent schemas, and leave error handling as an exercise for the model. APIs were designed for structured inputs from applications, not the natural language intent that comes from agents. The result: poor accuracy, frustrated users, and workflows that break unpredictably.
Arcade has developed thousands of agent-optimized MCP tools, including GitHub, Linear, Slack, Salesforce, Google Workspace, and many other integrations. These aren't wrappers. They're purpose-built for agents:
- Consistent schemas across all integrations so agents can reason about tools predictably
- Predictable error handling that agents can understand and recover from
- Semantic tool design where operations map to what agents actually want to do, not just what the underlying API exposes
So now you can build any agentic workflow that can not only connect to all the systems you care about, but can take actions on them with better reliability and lower costs.
One URL, All Your Tools
Instead of configuring multiple MCP servers, you select the tools you need—GitHub, Linear, Slack, Gmail, whatever your workflow requires—and Arcade bundles them into a Gateway. You get one URL that provides access to all of them.
https://api.arcade.dev/mcp/gateway/your-gateway-idPoint your MCP client at this URL. Done.
And if you have your own MCP servers? Bring them. Arcade's Gateway can aggregate tools from any source - Arcade's catalog, your custom servers, third-party MCP implementations – behind a single endpoint.
Portability Across Clients
The same Gateway URL works in Cursor, Claude Desktop*, VS Code, ChatGPT, and any other MCP-compatible client. Configure your tools once, use them everywhere.
Want to try that new IDE everyone's talking about? Your Gateway comes with you.
Multi-User by Default
Most MCP setups are fundamentally single-user. They work great on your machine, but scaling to a team means everyone manages their own tokens and their own configs. This is why so many agent projects never get past the demo stage.
Arcade MCP Gateways are multi-user from the start. Send a teammate the Gateway URL. They authenticate with their own credentials for each service – their Google account, their GitHub identity – and they're running the same toolset you are. Same tools, same reliability, their permissions.
The security context travels with the user, not the agent. That's what makes this actually deployable in a team environment.
Visibility Into What's Running
Gateways give you a single place to see what tools are available, what's been called, and what's happening across your integrations. No more black-box debugging.
Getting Started with MCP Gateways: Agentic Developer Workflow example
Let’s walk through what this can look like for a common developer workflow.
Every engineer runs this loop on repeat: grab a ticket from Linear, create a branch in GitHub, make your changes, open a PR, assign reviewers, close the ticket, and notify the team in Slack. Your agent already helps you code. With an Arcade Gateway, it can handle the rest too.
Tools needed: GitHub, Linear, Slack
Step 1: Create Your Gateway
Head to the Arcade Dashboard and create a new Gateway. Add these tools:
- GitHub — for branches, commits, and PRs
- Linear — for ticket management
- Slack — for team notifications
Within each Gateway, you pick exactly which tools to expose to your agent. This is where centralized governance happens—you decide which Gateway (and which team or use case) gets access to which tools. Three tools, one Gateway, one URL.
Step 2: Connect Your MCP Client
Add your Gateway URL to Cursor Settings -> Tools & MCP:
{
"mcpServers": {
"ARCADE-MCP": {
"url": "https://api.arcade.dev/mcp/engineering",
"headers": {
"Authorization": "Bearer arc_xxxxxxx",
"Arcade-User-ID": "john@acme.com"
}
}
}
}
Your agent now has access to GitHub, Linear, and Slack through a single connection.
Step 3: Authenticate
When your agent tries to access a tool it doesn't have permission for yet, Arcade detects this and prompts you to authorize just-in-time, with exactly the scopes needed for that action. No upfront permission grabs, no over-provisioning. You authorize what's needed, when it's needed.
These are first-party OAuth flows directly with each provider: GitHub, Linear, Slack, the same flows your security team already trusts. Once authorized, Arcade handles token refresh and lifecycle automatically.
Step 4: Run the Workflow
Open Cursor and tell your agent:
"Pick up SAL-20 from Linear, create a feature branch in GitHub Repo - https://github.com/ArcadeAI/F1-Pitwall. When I'm done with my changes, open a PR with a description based on the ticket, assign @evan as reviewer, close the Linear issue, and post an update to #engineering in Slack."Watch it happen. Your agent grabs the ticket, creates the branch, waits for you to code, opens the PR, updates Linear, and notifies the team all without leaving your IDE.
See It in Action
Here's a short demo showing the full setup and a GitHub → Linear workflow running in Cursor:
MCP Gateways for any use case or user
Different teams need different tools. Your engineering team needs GitHub and Linear. Support needs Zendesk and Confluence. Sales needs Salesforce and HubSpot.
You can create separate Gateways for each use case, each with its own curated toolset. Each Gateway becomes a managed endpoint for the specific workflow or team. Here's an example of what becomes possible when your agent has reliable tools behind a single Gateway.
Each persona gets a Gateway with exactly the tools they need. Different permission structures, same reliability. The developer workflow is the one most teams start with—issue to branch to PR to done, all from your IDE.
The Bigger Picture: Managing MCP Gateways at Scale
Here's where it gets interesting for platform teams and Arcade admins.
Arcade functions as a single runtime for all your MCP tools – whether they're from Arcade's catalog, custom-built, or third-party servers you bring yourself. Every Gateway is a single, manageable URL that plugs into this runtime.
Centralized governance. You decide which tools are available in which Gateway, with granular permissions. Engineering gets GitHub and Linear. Support gets Zendesk. Sales gets Salesforce. Each team has exactly the tools they need, nothing more. No MCP sprawl, no teams accidentally rebuilding servers that already exist.
Non-disruptive updates. Your team switches from ClickUp to Linear. In the old world, everyone reconfigures their local MCP setup. With Gateways, you update the Gateway once. Everyone using that Gateway URL gets the new tools automatically. Version control and safe rollouts built in.
Fine-grained audit logs. See what tools are being used, by which user, for which actions, across which services. This isn't just useful for debugging. It's the visibility your security team needs to actually approve agent deployments. OTEL-compatible for integration with your existing observability stack.
Scalable onboarding. New hire joins the team. Send them the Gateway URL. They authenticate with their own credentials. Done. They have the same toolset as everyone else, with their own permissions.
This is the shift: from "every developer manages their own MCP configuration" to "the platform team manages Gateways, any team can just use them." You get to accelerate AI development without sacrificing the control enterprise environments require.
Resources
Try It Free
MCP Gateways are now available as part of Arcade’s runtime. Create a Gateway, connect your client, and see what your agent can actually do when it has reliable tools behind it.
Have questions or want to share what you're building? Join the conversation on Discord or reach out at hello@arcade.dev.
*Claude Desktop will be coming soon
