No fluff. Just deep dives into tool-calling and agent auth to make your AI actually useful.
A comparison of 10 AI coding-agent harnesses and orchestration tools, including Claude Code, Codex, OpenCode, Conductor, Nimbalyst, Orca, Gas Town, OpenHands, LangGraph, and Deep Agents, grouped into built-in delegation, multi-agent workspaces, and programmable frameworks, plus where Arcade.dev governs the external actions they take.
Every connection between Duracell's AI agents and its business systems runs through Arcade.dev, permissioned per user and logged to the SIEM. That's why the team now connects a new business system about once a week.
An essay on what happens when the machine does exactly what you wanted: agents, delegated thinking, authority, and what understanding returns to the human.
A production-focused comparison of 9 AI agent management platforms, including Arcade.dev, Kore.ai AMP, ServiceNow AI Control Tower, IBM watsonx Orchestrate, Microsoft Agent 365, and Amazon Bedrock AgentCore, evaluated on governance, authorization, execution, audit evidence, and pricing.
A buyer's comparison of 15 AI governance platforms, including Credo AI, IBM watsonx.governance, OneTrust, ServiceNow AI Control Tower, Microsoft Agent 365, and Arcade.dev, grouped by what they govern: enterprise risk, model lifecycles, workforce AI, and production agent actions.
A comparison of 13 AI gateways across model routing, MCP access, and governed agent actions, including Arcade.dev, OpenRouter, LiteLLM, Portkey, Kong, and Amazon Bedrock AgentCore, with deployment, pricing, and tradeoffs for each.
Enterprise customers can now deploy custom MCP servers into their own environment with one command. Every server gets Arcade.dev's authorization, policy enforcement, and audit logging from its first call.
Connect OpenClaw to MCP tools through an Arcade.dev MCP Gateway so provider tokens stay off the OpenClaw host. Set up OAuth, limit tool access, and verify Gmail and Linear calls before you add writes or scheduled jobs.
Arcade.dev now supports MCP Apps, the extension that lets a tool show you an interactive interface. Gmail, Slack, and Outlook Mail drafts arrive editable, inside your chat.
Arcade.dev's co-author of URL Elicitation is recognized with the Agentic AI Foundation's Outstanding Technical Contribution Award.
Install the Arcade.dev Plugin in the agent you already use, sign in, and start calling tools. There is no MCP gateway to configure and no client settings to edit.
Connect Meta Muse to an Arcade.dev MCP Gateway with a chat-created Custom Connector, Streamable HTTP, and OAuth, then verify a read-only action before you enable writes.
Arcade.dev's Tool Recommendation gives your agent the whole tool catalog at a fraction of the token cost: up to 91% fewer input tokens per session, up to 37% lower token costs, and industry-leading odds of finding the right tool.
I was hired to ship Tool Recommendation. Nine months later, here's what it actually took: version numbers that broke agents, a missing newline that cost us points of recall, and air gaps that needed punching.
A comparison of nine DLP solutions for AI agents in 2026, including Arcade.dev, Prisma AIRS, Nightfall AI, Strac, Microsoft Purview, Netskope, Zscaler, Check Point AI Security, and Cyera, by enforcement point, observable data path, control granularity, and pricing.
A comparison of 10 prompt injection detection and defense tools for enterprise AI agents in 2026, from red-team scanners and production detectors to guardrails and Arcade.dev's action-boundary authorization, covering where each control runs and what it still leaves exposed.
Until now, Arcade.dev has been a product for admins. The Private Registry is the first thing we've built for the people using agents rather than the people configuring them — turning your gateway URL into a page employees can open and explore.
Six months after launch, ToolBench rescanned the ecosystem: 90,000+ MCP servers and 630,000+ tools. Only 0.28% earn an A, maintained servers are pulling ahead, and the riskiest tools still get the least documentation.
Cisco Investments is Arcade.dev's newest strategic investor, extending our oversubscribed Series A round to establish AI agent governance as a fundamental component of enterprise infrastructure.
Since our last round-up, Arcade.dev has shipped a rebuilt Microsoft Outlook toolkit, a new Snowflake toolkit, and optimized toolkits for Calendly and Airtable. Here's what your agents can do now.
A year ago AIO was a niche concept. Now it is a pillar of any marketing engine. Here is the weekly job Arcade.dev runs to watch how LLMs describe and cite us, why it is not an agent, and what six months of data taught us about content.
GitHub Copilot helps developers write code, but real developer work extends into Slack, Jira, Google Workspace, linear, github etc. Connecting Copilot to these tools locally is trivial. Doing it securely, without leaving raw tokens sitting in a config file, is not.
81% of teams have agents past planning. Only 14% have full security sign-off. The AI Agent Governance Playbook is a practitioner's guide to closing that gap at the action layer, where every tool call has to answer one question.
AI agent governance is centralized control over every agent, tool, and action in production. This six-stage lifecycle framework shows which stages an actions runtime enforces directly, and which still need an operating process.
Learn how to securely connect Grok Bot to Arcade using an MCP Gateway, OAuth, approval rules, and scoped tool access for safer automations and examples.
Prevention is only half of governance. Execution Tool Logs give you the other half: a record of every tool your agents run, who they ran it for, and whether it succeeded.
Grok Bot is the most capable agent harness I have used. I gave it my logged-in Clay session, it did the job, and it spent credits nobody can account for. Its own docs explain why that will not pass an enterprise security review.
OpenAI shipped support for Skills Over MCP while its spec, SEP-2640, is still an unmerged draft. What the extension is, how it works on the wire, what it unlocks, and where the largest implementation already diverges from the draft.
The return on AI shows up when agents take on whole workflows in production. That value stays locked until you can control, scale, and prove what an agent does the moment it acts.
Arcade.dev now lets your agent line up every authorization it needs before it starts. One approval link per service, scoped to the job, so long-running work stops stalling on a consent screen you're not there to click.
Governance for agents has to run where the action runs. This is what that looks like in practice: one control plane, one question, evaluated on every action an agent takes.
Adding guardrails is the right instinct and an incomplete one. A guardrail lives inside the model, the one part of your stack that can be talked past, and today's agents are capable enough to do the talking themselves.
Enterprises have governed people for decades. Letting agents inherit that work unchanged doesn't work — here's why.
Learn how to use MCP with Cursor to connect external APIs via Arcade: secure tool calls, no API keys in your IDE. Set up in minutes.
A month after the largest revision to the MCP spec, the debate over whether MCP is the right protocol is settled. Alex Salazar on what stateless actually fixed, and the three gaps that matter next.
Register any remote MCP server with Arcade.dev — from a vendor, a partner, or your own team — and govern its tools from one control plane, with every user authenticating as themselves.
A production-focused comparison of the leading TypeScript AI agent frameworks for Next.js in 2026 - Mastra, Vercel AI SDK, and LangChain/LangGraph, plus Inngest AgentKit, VoltAgent, Genkit, and the OpenAI Agents SDK - across execution model, tooling, and per-user authorization.
A production-focused comparison of 10 MCP server deployment platforms for enterprises - Arcade.dev, AWS Bedrock AgentCore, Azure, Google Cloud, Prefect Horizon, TrueFoundry, OpenShift, Kong, Cloudflare Workers, and MintMCP - across hosting, authorization, and action audit.
NVIDIA has launched the Open Secure AI Alliance, more than 120 companies building open technologies for AI safety and cybersecurity. Arcade.dev has joined as a founding partner.
A plugin is a software component that adds a capability to a host application without changing the host's code. Here's how the idea evolved from browser add-ons to WordPress, ChatGPT plugins, and MCP tools, and what it takes to run AI plugins in production.
Role-based access control is live in Arcade.dev. Assign organization admins, project admins, and members so you decide who can administer your organization and who can simply use the tools in it — and roll agents out across your whole company with confidence.
Learn how to securely integrate Pi with Model Context Protocol (MCP) tools using Arcade. Discover how to eliminate hardcoded API keys by using a remote action runtime for dynamic OAuth execution.
Connecting Claude Code to GitHub, Slack, or Jira usually means pasting API tokens into your terminal. Here is how to wire up MCP tools through Arcade.dev instead, so credentials stay vaulted and every action is authorized at execution time.
On July 28, MCP shipped the largest revision to its spec since launch, complete with breaking changes anyone running MCP servers needs to respond to. We pulled everything we know into one guide: what changed, why, and what you need to do about it.
Meta just shipped Glimmer, a 30B agentic model that runs on a single consumer GPU. It's a strong signal that model intelligence is getting commoditized, and that the real infrastructure question is what an agent is allowed to do once it can act.
Arcade.dev has acquired Smithery, the leading public registry and hosting platform for MCP. Smithery co-founder Anirudh Kamath is joining the Arcade team.
Arcade.dev is now an ecosystem partner in the Cisco Duo marketplace. Teams running Duo can enforce their existing identity and access policies on every action an AI agent takes.
The new MCP release brings a stateless core, first-class extensions, and authorization hardening — and someone has to absorb that churn. Arcade.dev speaks both protocol versions on day one, and keeps authorization, security, and governance in the runtime rather than the wire format.
The MCP 2026-07-28 release drops the initialize handshake and the session ID for remote servers. Arcade.dev's Nate Barbettini and Mateo Torres sit down with core maintainers Caitie McCaffrey (Microsoft) and Sam Morrow (GitHub) on why they took a breaking change this size — and what it costs to adopt.
The 2026-07-28 MCP draft goes stateless: no handshake, no sessions, no server-initiated requests. Here's the day-one checklist of what an MCP client has to handle to support it, what to build or demand from your runtime, and why Arcade.dev is compatible on day one.
The 'A2A vs. MCP' debate frames a false choice. They're two different layers: MCP is the execution layer present on almost every agent, and A2A is the coordination layer you add only for multi-agent systems. Here's how to decide, and why Arcade.dev keeps the tool layer cleanly separate.
Nothing breaks on day zero, but if you build or operate MCP servers, the July 28 switch to the stateless protocol is real work. Nate Barbettini's seven-step migration checklist — from weird day-zero traffic to the satisfying cleanup — plus where Arcade.dev absorbs the messy middle.
The July 28 MCP release goes stateless, hardens authorization, and makes extensions first-class — and those breaking changes are exactly why Arcade.dev is betting harder on MCP. A maturity story, and why the protocol debate is over.
Enterprise-Managed Authorization (EMA) lets an employee sign into an MCP client with company SSO and find every MCP server already connected — no consent screens, no API keys. Arcade.dev's Nate Barbettini and Wils Dawson sit down with Okta's Aaron Parecki and Anthropic's Paul Carleton to unpack how it works.
A production-focused comparison of 13 MCP gateways and runtimes for enterprise teams — including Arcade.dev, TrueFoundry, Composio, Docker MCP Gateway, Kong, and Amazon Bedrock AgentCore — across OAuth, tool abstraction, audit logs, deployment, and pricing.
In July alone, Arcade.dev shipped four new agent-optimized toolkits — Power BI, Postman, Fireflies, and Insightly — plus upgrades to Gmail, Excel, Outlook, and Linear. Here's what your agents can do now that they couldn't a month ago.
The new MCP release moves the core protocol from stateful to stateless, and session IDs are going away. Here's what breaks when you run MCP servers or gateways in production, what finally gets simpler, and how Arcade.dev lets you migrate on your own schedule.
The new MCP release gives extensions an official track, with their own release cadence and versioning. Good for a thin, stable core, but it formalizes fragmentation into a growing support matrix. Here's what changes and how a gateway helps.
Over 39,000 agent skills scored on SkillBench, and three findings matter most: a passing grade isn't a safety guarantee, tool boundaries are where describing becomes acting, and popularity doesn't predict quality.
Function calling, MCP, and A2A form a complementary protocol stack for AI agent tool calling. Here's how they fit together in 2026, and how to source agent-optimized tools that scale reliably and securely.
A production-focused comparison of the top AI agent integration platforms for 2026 — Arcade.dev, Composio, Nango, Merge, Workato, n8n, Zapier, and Make — across authorization, tool calling, observability, and pricing.
The pressure has shifted from having an AI story to having AI results, and token bills are piling up. Why the ROI reckoning is a good sign, and how better agent architecture, not spending blindly or pulling back, is the answer.
MCP stayed quiet on how clients should handle refresh tokens, so behavior drifted across the ecosystem. Wils Dawson on the clarification landing in the 2026 MCP release, and why refresh tokens are the gap that only shows up in production.
Building an MCP server on your laptop is easy; running one for 10,000 employees isn't. The 2026 MCP release reworks the protocol from stateful to stateless, dropping session IDs. Here's what's changing, why it breaks things, and the payoff.
On July 28, the newest MCP spec lands with breaking changes you'll have to respond to. Join Arcade.dev's webinar with Mateo Torres: what's changing, why, and how to prepare.
The skills ecosystem has grown to tens of thousands of published skills, but nothing judged their quality. SkillBench scores ~39,000 skills across six dimensions, from safety to tool boundaries, making it the largest graded index of agent skills anywhere.
From ChatGPT Work to Grok 4.5 to Muse Spark, the labs are all chasing enterprise knowledge work. But none of them shipped the enforcement, execution, or governance agents need to reach production, because that layer can't live in the model.
The workflows enterprises want to automate are cross-system by definition. A vendor-native agent that lives inside a CRM can only see one room in a connected house, which is why bolt-on agents are the wrong architecture.
A production-focused comparison of the 7 best AI agent authentication and authorization platforms for 2026 — Arcade.dev, Composio, AWS AgentCore, Nango, Merge, Auth0, and WorkOS — across delegated authorization, token vaulting, tool execution, deployment, and audit logs.
Arcade.dev sits in the path of every action an agent takes, so what happens when something breaks? How retries and failover absorb tool failures, why a compromise stays contained, and how you control runtime availability.
An AI agent broke into a company, encrypted its data, demanded a ransom, and then deleted the only key. What the first agentic ransomware attack tells us about autonomous execution, and why governing what agents do at runtime matters more than how smart they are.
No matter how fast we shipped MCP tools, it wasn't fast enough. So we let agents build them. Meet Gauntlet, the loop that produced 10 new toolkits in a weekend, work that used to take two months.
A comprehensive guide to connecting MCP servers to Google Antigravity with Arcade.dev. Secure your downstream credentials, manage tool execution, and chain authenticated actions directly from your IDE.
Once teams accept that the model never sees credentials, the next question is where the tokens live and who holds the keys. Arcade.dev stores them in an encrypted, per-user vault, in its cloud or entirely inside your own environment.
There's a tidy story that every SaaS vendor will own its MCP server, one-to-one with its API. It's wrong. APIs are service contracts; great MCP servers are intent contracts, and intents map to use cases, not vendors.
The companion to our background-agents post, in running code. An email triggers an agent that fixes a bug in a sandbox and opens a PR, and every action passes through per-user auth, just-in-time policy, and an audit trail you can query.
Arcade.dev is now in the Microsoft Azure and AWS marketplaces. One-click deploy runs Arcade's runtime inside your own cloud environment, governed by the security rules you already trust.
Want to connect MCP to Codex? Learn how to use Arcade.dev as your action runtime to securely authenticate and run tools like Calendar and Linear from your IDE.
A voice agent that files GitHub issues under each caller's own GitHub account, then hands the backlog to an AI maintainer that ships the best ones as real pull requests, all governed end-to-end by Arcade.dev.
Background agents run on a schedule or a trigger, with no one there to approve access. Arcade.dev decouples authorization from the live session so they act under real, delegated user authority, re-checked at the moment of every action.
When the threat of a jailbreak forced Anthropic to pull Fable 5, it revealed that guardrails aren't enough. You need deterministic controls at the action layer.
Connect OpenCode to MCP servers with Arcade.dev: test a local Git server, then route tool calls through a remote OAuth-backed gateway with downstream credentials vaulted away from the model.
A running diary from AI Engineer World's Fair 2026, tracking the talks worth knowing about, patterns across the expo floor, and ideas shaping the current agent boom.
Every enterprise AI security review asks the same thing: can the model see the credentials? With Arcade.dev, the LLM never touches a token. Credentials stay in the runtime, authorized just in time, never in the reasoning loop.
Cisco Duo owns the policy. Arcade.dev enforces it on every tool call, from login scopes to a real-time Duo Push the moment an agent reaches for sensitive data.
Connect Nous Research's Hermes Agent to a remote MCP server with Arcade.dev: native OAuth, agent-optimized tools, and downstream credentials vaulted away from the model.
OpenAI's GPT 5.6 ships as Sol, Terra, and Luna, with an ultra mode that runs sub-agents and a staged, government-coordinated rollout. The real story is what happens when ChatGPT becomes a workforce acting on real systems, and who authorizes every action. Here is the breakdown, plus where Arcade.dev fits.
An organization's most valuable tools are the ones kept off the public internet. Arcade Warp Pipes is a managed service that connects external AI clients to your private tools, on top of the governance Arcade.dev already provides.
Anthropic launched Claude Tag, a shared AI agent for Slack. Here's how it works and how to build a Claude Tag-style agent with Python, OpenAI, and Arcade.
Anthropic adopted Enterprise-Managed Authorization (EMA), a new MCP extension that lets identity providers grant server access centrally. Arcade.dev now supports it, and early access is open.
EMA centralizes MCP access provisioning, but it was never designed to authorize each tool call. Here's why connected agents also need per-action authorization at runtime.
Sending a file through an AI agent shouldn't cost a million tokens or a file picker. Here's how Arcade.dev keeps file bytes out of the model's context, and why MCP's file story needs a client-resolution mode before autonomous agents hit a wall.
The NSA's May 2026 Cybersecurity Information Sheet on MCP is effectively an RFP for every agentic AI program in the Fortune 500.
Arcade.dev raised $60M in Series A funding, led by SYN Ventures with strategic investment from Morgan Stanley and Wipro, to build the secure action layer for enterprise AI agents.
An AI agent ran up a $6,531 AWS bill doing exactly what it was told. The model didn't fail. The standing credential did. A note on what we actually delegate to agents.
Every AI agent that connects to a business system inherits enormous trust. A new class of OAuth attacks shows why agentic AI security has to be built at the architecture layer — and why vigilance is an ongoing discipline, not a one-time fix.
After Snowflake's intent to acquire Natoma, here's how the leading MCP runtime alternatives — Arcade.dev, AWS AgentCore, WorkOS, and Merge — compare on authorization, tool reliability, governance, and deployment flexibility.
A production-focused comparison of the top Composio alternatives in 2026 — Arcade.dev, AWS AgentCore, Merge, and Natoma — across authorization, governance, deployment, and migration complexity.
Anthropic just released Fable 5, the most capable model they have ever made generally available. More subagents and longer autonomy also mean an exponentially larger authorization surface. Here's what that means for enterprise AI teams.
The Arcade.dev team is always building, and now you can share the fun at Arcade Labs: our public home for research, prototypes, and experiments, launching today with Omni.
Microsoft Build 2026 made MCP the default integration layer across Foundry, Agent 365, Microsoft IQ, Copilot, and the local agent stack.
Claude Opus 4.8 and GPT-5.5 take the same cross-app Arcade task: read Slides, write a Doc, and send email. The winner depends on what you value.
Connect Arcade.dev MCP Gateways to the identity provider your company already runs. Deploying an agent to ten people or ten thousand looks the same.
Your AI agent prototype works—until it starts acting on behalf of other people. These are the six signs your in-house agents have outgrown DIY plumbing and need an MCP runtime for identity, policy, audit, integrations, reuse, and risk ownership.
A CISO-grade rubric for AI agent governance, organized around the four concerns every CISO faces in production — and the six runtime capabilities that turn governance from spreadsheets into enforceable controls at every tool call.
Multi-user AI agents need a delegated authorization stack — OAuth 2.1, OIDC, and an MCP runtime that enforces the user/agent intersection at every tool call. This guide breaks down the nine capabilities, two identities, and one strict rule that production deployments need in 2026.
MCP runtime build vs. buy in 2026 hinges on multi-user auth, audit-grade governance, and the ongoing maintenance load of custom OAuth and policy. This guide walks engineering leaders through the decision criteria and four tipping points.
Arcade.dev's guide to LangChain Interrupt 2026 (May 13–14, San Francisco): the must-see sessions and the agent infrastructure questions AI engineers and executives should be asking.
Most agents either forget everything between sessions or remember the wrong things in someone else's database. There's a third option: a memory layer you actually own.
Claude Code Routines enable unattended, cloud-run workflows via scheduled, API, and GitHub event triggers — but demo-grade setups break under enterprise load. Here are five production-leaning routines for engineering teams plus the MCP runtime patterns that make them safe to ship.
A 2026 taxonomy of the MCP ecosystem — registries, gateways, and runtimes — plus a feature-by-feature comparison of 8 platforms on per-user auth, audit logs, and private infrastructure support.
Anthropic just published a deep dive on the infrastructure behind their Managed Agents. It's excellent work on the agent's brain—and it highlights exactly what Arcade.dev solves for the hands.
Vercel and Context.ai disclosed a chained breach widely reported as an 'AI incident.' It wasn't. Context.ai had stored a Vercel employee's broadly-scoped Google Workspace OAuth token on its servers. When Context.ai's AWS got breached, the attacker replayed the token, logged in as the employee, pivoted into Vercel, and walked out with customer environment variables — later listed for $2M on BreachForums. No model was jailbroken. The vulnerability is a 2010s-era OAuth token hoarding pattern, and AI just made the vaults more valuable.
Five SRE workflows — incident triage, runbook execution, postmortem drafting, SLO investigation, on-call handoffs — that Claude Code can run today, and the auth, scope, and audit gap that decides whether they make the rotation.
Every developer has the same fantasy: wake up, get a voice briefing of everything that matters, and move on. I finally built it — in 15 minutes, with zero traditional code.
In just twenty-seven months, Anthropic went from $87 million to $30 billion in annualized revenue, surpassing OpenAI. Here's how strategic focus on enterprise, Claude Code, and MCP created one of the fastest revenue reversals in tech history.
GTM teams are among the first adopting AI agents for real work. Arcade.dev's ToolBench data reveals which go-to-market SaaS apps are actually ready for agent automation—and which ones are blocking the path.
Shaun Smith built Fast Agent, the first agent framework designed from the ground up for MCP. He also built the Hugging Face MCP server, and in a recent interview, he showed us how to combine them by deploying a sub-agent as a remote MCP server.
Securely connect AI agents to enterprise tools using an MCP runtime. Architecture guide covering OBO execution, JIT auth, token isolation, and 4 integration approaches compared.
Which enterprise software vendors are making their platforms accessible to AI agents, and which are keeping the doors locked? Arcade.dev's ToolBench rankings reveal the 5 most open and 5 most closed SaaS vendors for MCP connectivity.
Arcade.dev's agent-optimized MCP tools are now available in LangSmith Fleet, giving your agents access to 7,500+ reliable tools and secure auth infrastructure out of the box.
Critics say MCP is overkill, but the data tells a different story. Arcade.dev CEO Alex Salazar breaks down why MCP has already won the protocol war.
Rizel Scarlett led open-source developer relations at Block, where Goose continues to serve as the reference implementation for new protocol features. From MCP UI to MCP Apps, Goose is where standards meet reality.
Build an always-on WhatsApp AI assistant with working code. Uses Arcade.dev for secure auth, Claude Code for orchestration, and MCP for tool integration.
Arcade.dev has been selected to the 2026 Enterprise Tech 30 list by Wing Venture Capital, recognizing the most promising private companies across the enterprise technology stack.
Arcade.dev and Akto are partnering to bring runtime governance and AI security together, giving teams the infrastructure to deploy tool-using agents with real guardrails in place.
Melissa Herrera is a Senior Developer Advocate at Temporal who previously built multi-agent systems at DataStax and Langflow. She's now making the case that the fragility of complex agentic tool-calling chains is a solved problem if you treat your tools as workflows rather than fire-and-forget functions.
ToolBench grades every MCP server across definition quality, protocol compliance, security, and supportability. 41,902 servers indexed. Only 0.5% earned an A or above.
Jack Herrington has been shipping JavaScript for 40 years and educating developers on YouTube as the Blue Collar Coder. As a core contributor to TanStack, he's now building TanStack AI, a type-safe, provider-agnostic SDK for adding AI to web apps. Its upcoming Code Mode feature shows what happens when you let agents orchestrate MCP tools with TypeScript.
I've been thinking a lot about how coding agents interact with external services. At Arcade.dev, we build agentic tools, so I spend most of my days watching AI agents try to do real things in the real world. And one pattern keeps bugging me. We're building increasingly complex integrations to connect coding agents to MCP servers. Custom SDKs, persistent connections, elaborate client configurations. But here's the thing: these agents already know how to use the CLI. They've been trained on millions of shell sessions. curl, git, docker, npm. They know the patterns. Flags, stdin, stdout, pipes, exit codes it's all in there. So why are we teaching them a new interface?
Five new Arcade.dev Optimized MCP servers give your AI agent full read and write access across Microsoft Word, Excel, PowerPoint, OneDrive, and SharePoint — over 30 tools for real document automation.
Arcade's Salesforce MCP server went from 3 tools to 17 — covering leads, opportunities, tasks, and call logging. Your AI agent can now handle the full CRM workflow from first touch to closed deal.
Arcade's Microsoft Office 365 MCP servers give your agent full read and write access across Word, Excel, PowerPoint, OneDrive, and SharePoint. Over 30 production-grade tools — handling binary file formats, session management, concurrent edits, and the OAuth maze that is Microsoft Graph — so you don't have to.
Arcade.dev captures every administrative action across your AI agent runtime automatically — who did it, how, what changed, and when. Audit logs are on by default, with a filterable dashboard and a REST API.
Daytona's sandboxes are now available as agent-ready tools through Arcade.dev — 46 tools for sandbox management, code execution, file operations, Git workflows, and more, designed for autonomous AI agents.
Sam Morrow and his colleagues started building GitHub's MCP server as an internal side project. One year and a bumpy start later, it's the most-used remote MCP server in the world. Sam has much to teach us about scaling tool design, auth, and what agents actually need from an enterprise server.
We benchmarked two Attio MCP toolkits across 8 CRM queries. Arcade.dev consumed 7,426 tokens. Composio consumed 747,083. Here's the full breakdown of what caused the gap and what it means at scale.
Tool definitions are not function signatures. They are menu items an LLM reads to decide what to call and how to fill the arguments. This post covers what separates good tool definitions from bad ones, with before/after examples and a practical checklist.
Tool quality directly affects agent reliability. Arcade.dev Evals lets you test MCP tool definitions against LLM behavior in simulated conversations, scoring whether the model selects the right tool and populates arguments correctly, before you deploy to production.
Paul Asjes has been building SDKs at Stripe and WorkOS for years. Now, as DevX Lead at ElevenLabs, he's rethinking what developer education means when the learner is a developer's agent.
TL;DR: Arcade.dev protects AI agent tool execution with delegated identity, scoped tool access, and governance. Today we're extending that security model with Contextual Access: runtime hooks that let you inject your own security, compliance, and filtering logic directly into the tool execution pipeline across three hook points, via any webhook on every tool call.
Alex Nahas built MCP inside a browser at Amazon. Now Microsoft and Google are turning it into a W3C standard. This article is adapted from Alex's interview in our video series MCP MVP. Episode 1 features Alex Nahas, creator of MCP-B and a driving force behind the WebMCP specification.
The Moment Every few years, a new pattern language emerges that changes how we build software. In 1994, the Gang of Four gave us Design Patterns. In 2003, Hohpe and Woolf gave us Enterprise Integration Patterns. Since then: Microservices Patterns, Cloud Patterns, and now Agent Patterns. But there's a gap. Agents can chat and reason on their own - but they can't ‘act’ without tools. Standards like MCP have unlocked how agents discover and call tools. The protocol layer is solved. What's missin
OpenClaw (a.k.a. Moltbot, a.k.a. ClawdBot) went viral and became one of the most popular agentic harnesses in a matter of days. Peter Steinberger had a successful exit from PSPDFKit, and felt empty until the undeniable potential of AI sparked renewed motivation to build. And he's doing it it non-stop. OpenClaw approaches the idea of an Personal AI agent as a harness that communicates with you (or multiple users) in any of the supported channels in multiple sessions connected to the underlying
Before building vector infrastructure, consider federation: AI agents with tool access to your existing systems. For most enterprise use cases, that's all you need. Someone told you to pivot to AI. Add an AI layer. “We need to be AI-first.” Fair enough. So you start thinking: what does AI need? Data. Obviously. So the playbook writes itself: collect data in a central place, set up a vector database, do some chunking, build a RAG pipeline, maybe fine-tune a model. Then query it. Ship the chatb
MCP makes it easy to go from “agent” to “agent that takes action.” The trap is that success compounds: every new system becomes a new server, every team ships “just one more tool,” and soon your integration surface is too large to reason about, too inconsistent to secure, and too messy to operate. Meanwhile, the model gets blamed for failure modes that are actually integration design problems. Tool definitions balloon. Selection accuracy drops. Context gets eaten before anyone types a prompt. A
While building an AI demo has become trivially easy, production-grade deployments in enterprises have been stifled by performance issues, costs, and security vulnerabilities that their teams have been warning about. Today, we're addressing one of those vulnerabilities head-on. A new class of identity attack Security researchers at The Chinese University of Hong Kong recently identified new variants of COAT (Cross-app OAuth Account Takeover), an identity phishing attack targeting agentic AI a
Most conversations about AI agents still start the same way: models, prompts, frameworks, followed by an incredible looking demo. Then someone asks, “Okay… when can it ship to production?” That’s where things get a little awkward. The naked truth in the fading demo afterglow is that agents are apps. Which means they need identity, permissions, real integrations, and a way to behave predictably when something goes sideways. Without these components, any agent can dazzle a boardroom, but it won
AI agents have moved quickly from experimentation to real-world deployment. Over the past year, organizations have gone from asking whether agents work to figuring out how to deploy enterprise AI agents reliably at scale. The 2026 State of AI Agents Report from the Claude team captures this shift clearly. Drawing on insights from teams building with modern LLM agents—including those powered by models from providers like Anthropic—the report offers a grounded view of how agentic systems are bein
We spend a lot of time thinking about how to safely give AI agents access to real systems. Some of that is personal curiosity, and some of it comes from the work we do at Arcade.dev building agent infrastructure—especially the parts that tend to break once you move past toy demos. So when Docker released Docker Sandboxes, which let AI coding agents run inside an isolated container instead of directly on your laptop, we wanted to try it for real. Not as a demo, but on an actual codebase, doing the k
Docker recently announced Docker Sandboxes, a lightweight, containerized environment designed to let coding agents work with your project files without exposing your entire machine. It’s a thoughtful addition to the ecosystem and a clear sign that agent tooling is maturing. Sandboxing helps solve an important problem: agents need room to operate. They install packages, run code, and modify files — and giving them that freedom without exposing your laptop makes everyone sleep a little better. B
Right now, somewhere in San Francisco, a foundation model company is losing money serving your API call. OpenAI spent $8.67 billion on inference in the first nine months of 2025—nearly double their revenue for the same period. Sam Altman publicly admitted they lose money on $200-per-month ChatGPT Pro subscriptions. Anthropic burns 70% of every dollar they bring in. These companies are pricing their products below cost, subsidized by the largest concentration of venture capital in technology his
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
The agent ecosystem has a terminology problem that masks a real architectural choice. "Tools" and "skills" get used interchangeably in marketing decks and conference talks, but they represent fundamentally different approaches to extending agent capabilities. Understanding this distinction is the difference between building agents that work in demos versus agents that work in production. But here's the uncomfortable truth that gets lost in the semantic debates: from the agent's perspective, it'
TL;DR: Anthropic's new Tool Search is a step in the right direction-but if you're running 4,000+ tools across multiple services, it might not be ready for prime time. The promise Anthropic's Tool Search promises to let Claude "access thousands of tools without consuming its context window." Music to our ears. At Arcade, we maintain thousands of agent-optimized tools across Gmail, Slack, GitHub, HubSpot, Salesforce, and dozens more platforms. If anyone was going to stress-test this feature, it
I was recently in Amsterdam meeting with some of the largest enterprises, and they all raised the same challenge: how to give AI agents access to more tools without everything falling apart? The issue is that as soon as they hit 20-30 tools, token costs became untenable and selection accuracy plummeted. The pain has been so acute that many teams have been attempting (unsuccessfully) to build their own workarounds with RAG pipelines, only to hit performance walls. That's why I'm excited about
It’s popular to test Large Language Models (LLMs) by asking them to solve difficult puzzles, like multiplying huge numbers. These tests are interesting research benchmarks, but they can miss something important: real-world usefulness. When was the last time you asked a coworker to multiply a 20-digit number in their head, without a calculator? Real-world usefulness is not always well-represented by artificial benchmarks. Throughout history, humans have invented tools to boost their abilities: c
Comprehensive analysis of AI software scaling trends, infrastructure requirements, and deployment success metrics across enterprise and cloud environments The gap between AI adoption and scaled implementation defines the current state of enterprise AI, with 88% use AI regularly but nearly two-thirds of respondents say their organizations have not yet begun scaling AI across the enterprise. As the global AI market accelerates toward $3.68 trillion by 2034, organizations face mounting pressure t
Data-driven analysis of workflow automation effectiveness, enterprise implementation patterns, and measurable business outcomes across industries The gap between AI adoption and successful implementation defines the current automation landscape. While 88% of enterprises report regular AI use, only a fraction achieve measurable ROI—creating massive opportunity for organizations that solve the implementation challenge. The workflow automation market, valued at USD 23.77 billion in 2025, rewards
Analysis of agentic AI adoption patterns, ROI benchmarks, and enterprise deployment statistics shaping the future of autonomous AI systems The shift from conversational AI to autonomous agents capable of executing real-world tasks represents a fundamental transformation in enterprise technology. With 79% of organizations now reporting AI agent adoption and the market projected to reach $199.05 billion by 2034, agentic frameworks have moved from experimental curiosity to business necessity. Arc
Model Context Protocol (MCP) has become the missing link between AI assistants that chat and AI agents that execute. For supply chain and procurement leaders, this shift matters because Arcade's MCP runtime and AI tool-calling platform transforms MCP from a promising protocol into a production-ready MCP runtime for multi-user authorization across tools—enabling agents to securely act across ERPs, supplier portals, and logistics systems without exposing credentials to language models. Arcade's MC
Model Context Protocol (MCP) has emerged as the standardized framework enabling AI agents to securely interact with enterprise retail systems—from inventory management to customer service platforms. As 78% of companies already integrate AI into operations, retail leaders face a critical decision: build custom integrations for every platform or adopt the infrastructure that treats MCP as the "USB-C for AI." Arcade.dev's MCP runtime and AI tool-calling platform solves the core challenge holding back a
Key Takeaways * Insurance AI agents unlock $60-80 million in cost savings but fail at multi-user authorization: Property & casualty insurers report $60-80 million annually in cost savings from AI automation, yet agents stall at production because they can't securely act on behalf of thousands of independent agents, claims adjusters, and underwriters — Arcade.dev's MCP runtime solves this authorization gap * LangChain orchestrates workflows while Arcade enables secure action: LangChain provid
Key Takeaways * Multi-user authorization remains the primary barrier blocking production AI in financial services: Less than 30% of AI projects reach production, with 70% never reach production, largely due to security reviews — Arcade.dev solves this as the MCP runtime that enables and governs multi-user authorization across banking APIs, payment processors, and CRM platforms * LangChain provides orchestration, Arcade enables secure execution: LangChain's agent framework handles reasoning a
Key Takeaways * The AI agents market in financial services will grow from $490.2 million in 2024 to $4.48 billion by 2030, yet production deployment stalls at authorization: AI agents can help wealth advisors reclaim up to 75% of the time they currently spend on routine tasks like portfolio reporting, compliance alerts, and client onboarding — tasks agents can automate if they can securely act across Gmail, CRMs, and custodian platforms. Arcade.dev's MCP runtime solves the multi-user authoriz
Data-driven analysis of custom AI SDK market expansion, implementation success rates, and the infrastructure powering enterprise tool-calling applications Custom SDK implementations have become the backbone of AI-powered applications, with the agentic AI developer ecosystem projected to grow from $6.96 billion in 2025 to $42.56 billion by 2030. This explosive growth reflects enterprise demand for governed tool execution that goes beyond basic API integrations. Arcade.dev addresses this directl
Clinical Research Organizations face a critical infrastructure challenge: connecting AI systems to clinical trial data, regulatory platforms, and research databases without building custom integrations for every single connection. Model Context Protocol (MCP), introduced by Anthropic in late 2024, provides the standardized framework CROs need—but only when paired with an MCP runtime and production-grade multi-user authorization platform like Arcade.dev that handles the complex token and secret m
Medical device manufacturers face a critical challenge: connecting AI agents to regulated systems without breaking HIPAA, FDA, or GxP compliance. Model Context Protocol (MCP) offers a standardized solution—but only when implemented with enterprise-grade security and multi-user authorization. Arcade's MCP runtime provides the MCP-compatible infrastructure that enables medical device companies to deploy AI agents with production-grade multi-user authorization, token and secret management, and the
Your scientists spend significant time searching PubMed, patent databases, and internal documentation manually. Your AI agents can't access proprietary compound data. Every new AI integration requires weeks of custom development. Model Context Protocol (MCP) solves all three challenges by giving AI agents secure, governed access to the specialized data sources biotech R&D relies on—from literature databases to LIMS systems—through one standardized protocol instead of dozens of fragile custom con
Healthcare leaders recognize automation's urgency: 92% cite automation as critical for addressing staff shortages. Yet only 30% of AI pilots reach production due to integration and multi-user authorization barriers. Model Context Protocol (MCP) solves the M×N integration problem blocking deployment at scale. Your Electronic Health Record has an API. Your data warehouse has an API. Your billing system has an API. But your AI agents can't securely act on behalf of multiple users across these syste
Your AI assistant just queried QuickBooks for a client's transaction history, pulled audit evidence from Vanta, and flagged three suspicious invoices—all in under five minutes. But can you prove to regulators exactly which data it accessed, who authorized those actions, and that sensitive financial information never leaked to the underlying AI model? This is the multi-user authorization challenge that Arcade's MCP runtime and AI tool-calling platform solves, transforming AI from a compliance ris
Wealth managers spend 40% of their time on data drudgery—compiling reports, toggling between systems, answering routine client questions. Meanwhile, compliance teams sift through 220 regulatory alerts daily. This productivity drain costs firms millions in lost advisory hours while exposing them to missed compliance deadlines. Arcade's AI tool-calling platform solves this challenge through Model Context Protocol (MCP), enabling AI agents to securely act on behalf of users with delegated permissio
You tell your AI agent: “Send that report to my manager.” It drafts the perfect message — and then stops. The problem isn’t intelligence; it’s identity. It can’t press “send,” because your email — like every good enterprise system — lives behind an auth wall. That’s the invisible barrier keeping AI from doing real work: agents can’t safely act on behalf of their users. That small roadblock points to a much bigger one. AI agents can reason, plan, and communicate — but they’ve been locked out
The global payments industry processes $2.0 quadrillion in value flows annually, generating $2.5 trillion in revenue. Yet despite decades of digital transformation investment, critical banking operations,anti-money laundering investigation, KYC onboarding, payment reconciliation,remain largely manual. Model Context Protocol (MCP) represents the infrastructure breakthrough that enables financial institutions to move beyond chatbot pilots to production-grade AI agents that take multi-user authoriz
The insurance industry faces a pivotal transformation moment. Model Context Protocol (MCP) has moved from experimental technology to production infrastructure, with 16,000+ active servers deployed across enterprises and millions of weekly SDK downloads. For InsurTech leaders, the question is no longer whether to adopt MCP, but how to implement it securely and effectively. Arcade's platform provides the MCP runtime for secure, multi-user authorization so AI agents can act on behalf of users acros
Model Context Protocol has emerged as the missing infrastructure layer that enables AI agents to act securely across financial systems. For fintech leaders navigating the $1 trillion AI opportunity in banking, MCP solves a critical problem: how to grant AI systems the precise, delegated permissions needed to execute real transactions without exposing tokens or credentials to language models. Arcade's MCP runtime provides the production-grade authorization layer that transforms AI pilots into sec
Key Takeaways * Banking AI agents face a multi-user authorization bottleneck, not a chatbot problem: While 51% of organizations already have AI agents in production, financial institutions struggle with secure multi-user authorization,Arcade.dev's MCP runtime solves this by enabling delegated user permissions and scoped access across Gmail, Slack, Salesforce, and core banking systems * LangChain dominates orchestration but requires Arcade for production banking: LangChain's 99K+ GitHub stars
Critical performance indicators for measuring security operations center efficiency, false positive reduction, and threat response acceleration in AI-powered alert detection systems Security teams receive an overwhelming 4,484 alerts daily, with analysts spending nearly three hours manually triaging this flood of potential threats. AI-powered alert detection delivers transformative improvements: 60% better threat detection over legacy tools, 74% faster detection. Arcade's AI platform enables s
Comprehensive analysis of AI compute optimization strategies, cost reduction opportunities, and efficiency improvements transforming enterprise AI deployments The explosion of AI infrastructure spending creates unprecedented pressure for compute optimization, with organizations now allocating an average of $85,521 monthly to AI budgets in 2025—a 36% increase from just one year prior. As the industry races toward a $6.7 trillion infrastructure requirement by 2030, software-level optimization de
Comprehensive analysis of federal AI authentication deployment, compliance frameworks, and the infrastructure powering 1,700+ government AI systems Federal agencies are rapidly scaling AI-powered authentication systems. The explosive growth creates unprecedented demand for secure, compliant authentication infrastructure capable of managing millions of user credentials while meeting stringent NIST and OMB requirements. Arcade's authenticated tool-calling addresses these federal needs with OAuth
Comprehensive analysis of retention rates, engagement patterns, and monetization metrics across ChatGPT, Google AI, Perplexity AI, and other leading AI platforms AI platforms face a critical monetization challenge despite massive user adoption—only 3% convert to paid subscriptions from a global base of 1.8 billion users, creating a $12 billion market that could theoretically reach $432 billion annually. The platforms that succeed in retention demonstrate clear patterns: ChatGPT Plus leads with
Comprehensive analysis of MLOps community growth, enterprise implementation success rates, and the infrastructure transforming machine learning from experimentation to production at scale The MLOps community is experiencing explosive growth as organizations transition from AI experimentation to production deployment, with the global market expanding from $1.7 billion in 2024 to a projected $39 billion by 2034. Enterprise adoption has reached 87% among large companies, revealing a massive infra
Comprehensive analysis of AI marketing tool integration statistics, from authentication success rates to automation performance metrics and enterprise adoption patterns The shift from experimental AI pilots to production marketing automation marks a fundamental transformation in how organizations execute campaigns. Yet technical challenges persist despite proven 300% average ROI. Arcade's AI tool-calling platform eliminates integration friction with OAuth 2.1 authentication, 100+ pre-built mar
Comprehensive analysis of open-source AI tool adoption patterns, cost efficiency drivers, and community-driven innovation metrics shaping AI development in 2025 Open-source AI tools have transformed from experimental projects to production-ready platforms, with over 50% of organizations now implementing these solutions across their AI technology stack. The shift from proprietary to community-driven development enables customization, eliminates vendor lock-in, and accelerates innovation through
Your MCP server works perfectly on localhost. Five green checkmarks. Clean logs. You're a genius! Then you try to deploy it. OAuth tokens leak into logs. Secrets are hardcoded because "it's just a prototype." The whole thing crashes under two concurrent users. Welcome to production. Every developer hits this wall. You can build an MCP server in an afternoon, but making it production-ready usually means rewriting half of it. New auth flows. Proper secret management. Multi-user context handlin
Comprehensive analysis of AI integration in DevOps workflows, productivity improvements, market expansion, and implementation success patterns across enterprises and development teams The integration of artificial intelligence into DevOps practices represents one of the most significant transformations in software development, with 90% of technology professionals now using AI in their daily work. Organizations implementing AI-powered DevOps fewer failure rates to 0–15% vs 46–60% for low perfor
Comprehensive analysis of model performance, resource utilization, deployment health, and cost efficiency metrics for production AI systems The transition from prototype to production AI requires rigorous measurement across performance, infrastructure, and operational dimensions. Organizations face critical challenges, with 74% dissatisfied with current resource allocation tools and only 7% achieving above 85% GPU utilization during peak periods. Arcade's AI platform transforms these infrastru
Comprehensive analysis of production AI deployment patterns, authenticated tool execution adoption, and enterprise implementation success metrics across platforms and industries The shift from experimental AI chatbots to production-grade systems executing real actions marks 2025's defining infrastructure evolution. With 78% of organizations now running AI in production environments—up from 55% just one year earlier—the industry has moved decisively beyond prototypes. Yet only 5% of custom tool
Comprehensive analysis of AI tool monetization trends, usage-based pricing adoption, enterprise spending patterns, and revenue generation strategies across platforms and industries The transformation from AI experimentation to profitable revenue streams marks 2025's defining business shift, with authenticated tool execution enabling companies to charge for actual value delivered rather than simple API access. More than half of organizations now use AI in at least one business function, while t
Comprehensive analysis of sales AI agent performance across conversion optimization, productivity improvements, revenue impact, and deployment reliability metrics from 2025 enterprise implementations Sales AI agents have evolved from experimental tools to production-ready systems that autonomously execute complex sales tasks, with major enterprise adoption of AI-powered sales tools across organizations. Unlike traditional chatbots, these agents proactively qualify leads, personalize outreach,
Data-driven analysis of AI scheduling market growth, productivity improvements, and how authenticated calendar integrations are transforming time management for modern teams The calendar and scheduling software market is experiencing explosive growth as organizations recognize that effective time management directly impacts their bottom line. The appointment scheduling software market will reach $1,518.4 million by 2032, up from $546.1 million in 2025, a 15.7% compound annual growth rate. AI-p
Comprehensive analysis of OAuth implementation patterns, enterprise adoption rates, and security vulnerabilities across industries and platforms OAuth 2.0 (authorization) and OpenID Connect (authentication) underpin modern digital identity, with 87% of technology companies implementing multi-factor authentication solutions. The global authentication market reaches $16.3 billion in 2024 while growing at 15.2% annually, yet implementation challenges persist with 46% of daily signup attempts meeti
Comprehensive analysis of AI integration platform adoption patterns, enterprise deployment trends, and measurable business outcomes across industries The transformation from isolated AI experiments to integrated enterprise systems marks 2025's defining technology shift, with 78% of organizations now deploying AI in at least one business function. Market projections show the enterprise AI sector reaching $323.54 billion by 2032, growing at an unprecedented 48.70% annually. Arcade's tool-calling
Comprehensive analysis of autonomous AI agent deployment, ROI projections, and implementation success patterns across industries and use cases The shift from passive AI assistants to autonomous agents marks a fundamental transformation in enterprise technology, with 79% of organizations reporting at least some level of AI agent adoption and 19% deploying agents at scale. This evolution from simple chat interfaces to action-taking systems drives unprecedented market growth, with the agentic AI s
Comprehensive analysis of AI security deployment patterns, authentication frameworks, and enterprise protection strategies across tool-calling platforms The gap between AI adoption and security preparedness creates unprecedented risks, with 90% of organizations implementing AI while only 5% feel confident in their security measures. Organizations face average breach costs of $670,000 when using high levels of shadow AI, yet those with extensive AI security save $1.9 million in breach-related ex
Comprehensive analysis of authentication security metrics, OAuth implementation patterns, and integration performance benchmarks across enterprise platforms The shift from basic API access to secure, multi-user authentication represents the foundation of modern software integration, with 84% of security professionals experiencing API security incidents in the past year alone. Authentication failures consistently rank among the top security vulnerabilities, while 7,000 password attacks are block
Comprehensive analysis of autonomous AI agent capabilities, enterprise deployment patterns, and development frameworks transforming how AI takes action beyond chat interfaces The evolution from conversational AI to autonomous agents represents a fundamental shift in artificial intelligence capabilities, with the global AI agents market reaching $5.25 billion in 2024 and projected to grow to $52.62 billion by 2030. This 46.3% annual growth rate reflects enterprises moving beyond simple chatbots
The biggest unlock for production AI agents isn't better models—it's accepting that agents are just applications. That sounds obvious. Maybe even boring. But this one realization cuts through years of confusion, eliminates entire categories of "new" security problems, and makes multi-user agent deployment actually feasible. Here's why it matters. The Non-Human Identity Trap When agents started hitting the enterprise conversation around 2023, identity companies rushed to define the problem.
Your agent needs to pull data from Google Drive, post a summary to Slack, and create a Jira ticket. Simple request. But whose credentials does it use? Should it have permission to delete your entire Drive folder? This authorization problem kills agent demos before they reach production. It's not about users logging into your agent (LangGraph Platform handles that). It's about your agent accessing other services on behalf of those users. If you're building real agents, you've hit this wall. The
The 70% of AI projects that never reach production have something in common: they hit the authentication wall and never recover. Tradestack broke through it by leveraging Arcade.dev’s capabilities. When Vaibhav Pandey and his team at Tradestack set out to build an agentic back office for UK contractors, they faced a challenge that kills most agent projects: giving AI secure, reliable access to critical business systems. Their target customers (mid-market contractors juggling invoicing, estimates,
Today, we’re launching the second iteration of our pricing plan. We’re walking through the details so you can see how we’re making our authorization and tool management platform accessible to even more developers and their agents. Our goal is to get your agents into production. This involves not just calling well-designed, LLM-consumable tools, but also authorizing many end users into your agent, which is not yet possible with MCP Servers. Our first pricing plan charged based on the number of
Here's a fact that keeps enterprise CTOs up at night: 70% of AI agent projects never reach production. The primary killer? Security reviews that reveal agents can't be trusted with enterprise systems. Today, Arcade.dev achieved SOC 2 Type 2 certification. But unlike typical compliance announcements, this isn't about checking boxes. It's about solving the fundamental trust problem that blocks agent deployment (and we checked the boxes too). Why Agent Security Hits Different Traditional softwa
Most AI agents are glorified chatbots. Chex just won a hackathon by building three specialized agents that actually book therapy appointments. Not suggest. Not recommend. Actually book — complete with calendar invites and email confirmations. Here's the pattern they discovered that you can steal for your own agent systems. Want to skip to the code? Check out our Quickstart or get your Arcade.dev API key to build authenticated agents in minutes. The Problem: Single Agents Hit Walls Traditio
Remember that moment when you realized your phone could do more than make calls? Today feels like that—but bigger. Arcade.dev and Lithic just unlocked true agentic commerce: AI agents that can browse, compare, and actually complete purchases. This isn't another chatbot that helps you shop. This is autonomous AI that shops for you. The Agentic Commerce Problem We All Pretended Didn't Exist Here's the dirty secret: Every "agentic commerce" demo you've seen stops at checkout. Why? Because nobod
Operational vs Exploratory tools, least‑privilege access, and patterns that make LLMs reliable partners
See URL Mode Elicitation in Action → Watch our engineer Will Dawson walk through the new MCP proposal that's solving one of the biggest security gaps in AI tool-calling. In 15 minutes, you'll see how agents can finally handle OAuth flows, payment confirmations, and API keys without exposing sensitive data to the LLM. Watch the technical walkthrough → Your AI agent needs to search Gmail for that weekly report. You've built an MCP server, the tool definition, everything's wired up perfectly. One
After eight years building authentication systems at Okta, followed by stints at Kong and ngrok working on developer tools and API gateways, I've seen how to build systems that are secure by default. Now at Arcade.dev, I'm watching the MCP ecosystem struggle to get there. The Model Context Protocol has incredible potential for enabling AI agents to interact with real-world systems. But there's a gap between experimental implementations and production-ready infrastructure that most developers ar
Your AI can summarize documents you feed it, answer questions about your uploaded PDFs, and explain concepts from its training data. But ask it to pull your actual Q4 revenue from NetSuite, check real customer satisfaction scores, or update a deal in Salesforce? Suddenly it's just guessing—or worse, hallucinating numbers that sound plausible but aren't your data. This disconnect between AI's intelligence and its ability to access real data and take action is why less than 30% of AI projects hav
Arcade.dev just took home "Overall Authentication Solution of the Year" in the 8th Annual AI Breakthrough Awards. And before you roll your eyes at another tech award announcement, let me explain why this actually matters for anyone building AI agents that need to do real work. The Problem We All Keep Hitting You know that moment when your perfectly crafted AI agent suggests "I'll schedule that meeting for you" — and then... doesn't? Because it can't? Yeah, that's the wall everyone's been hit
In the previous post in this series, we explored Human-in-the-Loop. Here, we’re exploring Handoffs, which I prefer to call “Agentic Delegation” This post is a companion to a video, I encourage you to watch it! Here’s the experiment setup I’m using the same agentic system. I implemented the same system using three different Frameworks: * LangGraph * OpenAI’s Agents SDK * Google’s Agent Development Kit (ADK) In all cases, the agent uses a “supervisor” architecture, where a single agent re
As I build agents every day, I get to see Agentic Frameworks evolve different approaches to solve the same core issues of agentic orchestration. Fundamentally, the differences come down to how the framework designers think about the common building blocks of an agentic system. Unfortunately, they all come with disparate terminology and adopt jargon that makes this seem more complicated than it really is. I feel this is creating a bit of a decision block, especially in beginners. This series of b
As the world becomes more and more agentic, it’s important to meet your users where they are, and this usually means providing them with polished UX in whatever communication platforms they use on a daily basis: * WhatsApp * Email * Telegram * Discord * Slack Adding a chatbot experience to chat-like interfaces is usually pretty easy. I just pick one of the existing LLM clients, add my API Key, a nice system prompt, and let users chat away. However, things quickly become complex if the age
At the Interrupt Conference, LangChain unveiled a new agent platform that allows developers to build and share AI agents. The platform leverages Arcade.dev's support for Model Context Protocol (MCP) to enable agents to perform actions on behalf of users across hundreds of services. Why This Matters: * Complete Agent Ecosystem: Developers can now build, share, and deploy AI agents through an intuitive platform with flexible hosting options * Powerful Action Capabilities: Thanks to Arcade.dev
LangChain's Social Media Agent is a fantastic tool. It allows you to take a list of links – maybe articles you've read, interesting projects, or company blog posts – and automatically generate engaging social media updates. Imagine processing 50 links and scheduling them out over the next few weeks. You could go on vacation knowing your social media feed remains active and consistent with content you've already approved. That's powerful automation! The Challenge: The Terminal Barrier While po
As AI agents and LLM-based applications become increasingly sophisticated, developers face unprecedented challenges in securing these autonomous systems. The intersection of artificial intelligence with identity management has created a complex landscape where traditional security paradigms prove inadequate. This report examines the fundamental questions developers are grappling with as they attempt to build secure, scalable AI systems in this rapidly evolving space. Reconceptualizing Identity
Multi-agent AI systems represent one of the most significant advances in practical AI applications today. Unlike traditional single-agent approaches, multi-agent systems distribute complex tasks across specialized agents, each handling what they do best. In this article, we'll explore a practical example that uses specialized agents with access to Gmail and Slack tools. This involves the integration of two frameworks. The OpenAI Agents SDK will run and orchestrate the agents, and Arcade will
AI agents often need to access multiple services and data sources on behalf of users. This introduces unique authentication and authorization challenges that go beyond typical single sign-on (SSO) for human users. Unlike a standard web app, an AI agent might operate without a user interface and even make autonomous decisions. To keep these agents secure and effective, it's critical to use best practices like least-privilege access and just-in-time authentication, and to understand where traditio
As we step into 2025, AI-powered email automation has become a game-changer for productivity. Building your own AI agent for Gmail can transform how you manage communications, prioritize messages, and handle routine email tasks. This guide introduces the key concepts of creating a custom Gmail AI assistant, with special attention to security and authentication. Want to see exactly how it's done? Watch our complete YouTube tutorial for a step-by-step walkthrough on how to build your own Gmail AI
What is MCP? Model Context Protocol (MCP) is having a moment, and for good reason: it's an open, standard way to connect tools and agents. At Arcade, we're thrilled to see the industry adopting an open standard for tool calling, because it means even more options and flexibility for devs building agents. Easily connect to any MCP Server with Arcade Today, we're excited to release native support for MCP servers in Arcade! Arcade can now connect to any MCP server supporting the new streamable
Last week, we hit a major company milestone - and you can read all about it in TechCrunch! Arcade.dev secured $12 million in funding from Laude Ventures. For those who haven't heard the full story, our co-founders Alex Salazar (former Okta exec) and Sam Partee (former Redis engineer) initially set out to build something quite different than what Arcade has become. This investment marks the first publicly announced funding from Laude, the new fund launched by Perplexity co-founder Andy Konwinski. I
How to use AI to query a customer database without writing SQL You've finally made it to Data Analyst at your dream company (yay!). You're excited to finally put all those hardcore SQL skills you've acquired over the years, maybe even use some of the new and shiny dataframe frameworks. You get to your desk with a freshly brewed cup of coffee, ready to dive deep into the latest of the latest. But the top urgent requests are the usual, "Hey! Could you give me a list of our customers in New York w
Today we're launching Arcade.dev Deploy, solving a critical challenge in AI development: how to quickly build, deploy, and iterate on custom tools that expand what your AI can do. With Arcade Deploy, you use our SDK to create specialized tools, then deploy them instantly to our cloud with a single command: arcade deploy. Your tools become immediately available to your AI models in your agent or application—no servers to manage, no complex infrastructure to configure, no deployment pipelines to buil
We're excited to announce that Arcade.dev has raised $12M in seed funding to tackle the biggest bottleneck in AI: secure authentication for agents. Secure Authentication for Agents You probably use ChatGPT or Claude to write emails for you. But have you noticed that you can't send that email directly from those agents? You can work with AI to plan a meal but it can't order the ingredients. You might ask it to book flights, but it can't complete the transaction. Some products let you pull file
AI agents promise to transform how we interact with technology, but at what cost to our privacy? As these digital assistants gain the power to act on our behalf, they're raising fundamental questions about security that can no longer be ignored. The Security Gap in AI Action Signal President Meredith Whittaker recently warned about the security and privacy challenges of agentic AI, describing it as "putting your brain in a jar." Her concerns highlight a critical reality: for AI agents to be u
LLMs acting on behalf of humans and interacting with real-world systems isn't theoretical anymore - with the advent of function calling, it is now a reality. And with Arcade.dev, function calling becomes a superpower that connects LLMs to authorized APIs, user services, and complex systems. With this shift, we're seeing the emergence of a new software practice: Machine Experience Engineering (MX Engineering). The Current Reality For AI models to handle our emails, schedule appointments, and manag
ChatGPT can't send emails, order food, or book flights. It can write SQL but can't query databases or work well with the data results. AI can't connect to the real world. It can't authenticate to access your accounts or use your data. This disconnect is partly why less than 30% of AI projects go to production. The biggest opportunity in AI today isn't better AI models—it's enabling those models to take real actions. Developers need secure connections between AI and authenticated services, user
