July 2026 Summaries

The recent release of the Model Context Protocol (MCP) marks its most significant update, featuring a stateless core, first-class extensions, and enhanced authorization, aligning it with OAuth and OpenID Connect deployment practices. This release poses challenges, such as deprecated features and extension-induced changes, requiring adaptation by enterprises that deploy production agents. Arcade, an enterprise AI actions runtime, provides a solution by supporting both new and older protocol versions, allowing a gradual transition to the stateless protocol. It acts as an MCP gateway, managing client-server interactions and centralizing updates to accommodate protocol changes. Arcade emphasizes the importance of maintaining consistent authorization, security, and governance controls within the runtime layer, independently of protocol specifics, ensuring these critical aspects remain stable amidst evolving technical environments. This approach minimizes the burden on teams managing compatibility issues and offers comprehensive resources to navigate the new MCP specifications.

The MCP 2026-07-28 release marks a significant overhaul of the protocol, primarily due to its transition to a stateless framework, eliminating the need for session IDs and the initialize command for remote servers. This change was driven by inefficiencies observed at Microsoft, where a substantial portion of protocol messages were deemed unnecessary, as most use cases did not require the stateful features. Caitie McCaffrey from Microsoft and Sam Morrow from GitHub discussed the rationale and implications of this breaking change, noting that the previous statefulness of the protocol was inconsistently implemented across hosts, leading to compatibility issues. GitHub has already adopted the new protocol, successfully handling over 100,000 requests with minimal challenges, primarily involving the removal of redundant elements, and reporting positive outcomes from the transition. The revision aims to streamline operations, reduce overhead, and enhance compatibility, with detailed guidance available through Arcade's comprehensive coverage.

The upcoming revision of the Model Context Protocol (MCP), set for release on July 28, 2026, represents a major overhaul by transitioning to a stateless protocol. This change removes the initialize handshake and sessions, ensuring that each tool call is a self-contained HTTP request with its own protocol version, identity, and capabilities. This transformation simplifies scalability, load balancing, and understanding the protocol, as server replicas can independently handle requests without retaining session information. The shift necessitates changes in the MCP client, which now has to explicitly manage tasks that were previously handled implicitly within persistent connections. Key benefits include improved workflows, such as handling human-in-the-loop pauses and managing per-user identity across services, enhancing reliability and security. While the transition to a stateless protocol involves significant updates, particularly in managing authentication and token lifecycles, platforms like Arcade are prepared to support the new spec from the start, ensuring seamless integration and operation.

The Model Context Protocol (MCP) has undergone its largest revision since launch, marking a significant maturation into a robust infrastructure suitable for enterprise production environments. Key changes include the transition to a stateless core, enhanced authorization aligning with OAuth 2.0 and OpenID Connect standards, and the elevation of extensions to first-class status, facilitating a lean core and expanding ecosystem. Initially met with skepticism due to its stateful, single-machine design, MCP has evolved by addressing scalability issues, thereby becoming the default standard for agent communication and attracting substantial community investment. This transformation underscores MCP's establishment as a dominant protocol, crucial for building production-ready agents, as it now integrates seamlessly with APIs and offers nuanced authorization capabilities that surpass CLI limitations. The revisions reflect a commitment to sustainable infrastructure, with formal deprecation policies and ongoing enhancements that align with enterprise needs, reinforcing MCP as a pivotal technology in modern agent-based architectures.

The recent update to the MCP protocol involves significant changes, including the elimination of session IDs as MCP transitions to a stateless protocol. While this change may not impact those who have only run servers on personal devices, it requires substantial adjustments for those involved in building or operating MCP servers. The migration process is not overly complex, but it requires careful planning and execution, including handling unexpected traffic, deciding whether to augment or rewrite server architecture, and checking for deprecated and altered features. Key steps involve implementing the new protocol, verifying compliance with an open-source conformance suite, and planning for a dual-stack period where both old and new protocols operate simultaneously. Ultimately, the transition will allow for a more efficient system, and tools like Arcade.dev provide support in managing this shift by bridging old and new protocol communications and maintaining consistent security and governance controls. This comprehensive approach ensures a smooth migration to the new MCP specification without disrupting server-client interactions.

Enterprise-Managed Authorization (EMA), the name for the Identity Assertion Authorization Grant (ID-JAG) within the MCP framework, is a new approach to identity management that eliminates consent screens and manual credential configurations by integrating company SSO with MCP servers. This system, discussed by experts from Okta and Anthropic, challenges the traditional OAuth consent prompt, which is deemed unnecessary in enterprise contexts where data-sharing agreements are made on behalf of the company. Despite initial resistance from IT admins, employees favor this streamlined authorization process, which shifts administrative pressures towards preventing corporate accounts from accessing personal ones. EMA remains an extension rather than part of the core MCP spec, emphasizing an extensions-first approach, and has influenced dynamic client registration, moving recommendations to client ID metadata documents. Predictions for the future include the adoption of proof-of-possession tokens and potential security incidents that could push further innovations in workload identity for agents, marking EMA as a significant evolution in enterprise identity management.

The debate between Agent-to-Agent (A2A) and Model Context Protocol (MCP) within the agent ecosystem is often oversimplified into a binary choice, whereas they actually represent distinct layers with different functions: MCP as the constant execution layer and A2A as the optional coordination layer. The recent MCP release, dated July 28, 2026, enhances tool layer capabilities like stateless scaling and async tasks without altering its foundational role, while A2A remains a development-focused coordination protocol for multi-agent systems across different teams or organizations. MCP has established itself as the default standard for agent-to-tool connectivity, widely adopted and supported by major tech companies, whereas A2A is still in early adoption stages with potential for growth. The real architectural decision lies in determining which layers a system needs based on specific use cases, such as whether there's a need for agent coordination or simply execution of tasks. The discussion around identity, both user and agent, remains unresolved, highlighting a need for flexible enforcement practices that are not tied to any single identity standard. Arcade.dev positions itself as a runtime that supports MCP's tool layer independently of protocol dependencies, emphasizing the separation of coordination and execution for effective policy enforcement and identity management.

In the complex landscape of Model Context Protocol (MCP) servers, connecting these systems safely to business operations is a primary challenge that has evolved from an architectural experiment to a critical enterprise governance requirement. The sprawl of tool servers and unmanaged access tokens complicates production rollouts, necessitating a robust MCP gateway to manage deployment effectively. Lightweight gateways like Docker MCP Gateway cater to local prototyping, while enterprise production demands a comprehensive action runtime that incorporates gateway federation with multi-user authorization, vaulted credentials, and audit logs for security and compliance. Arcade.dev emerges as a leading solution, offering an action runtime that integrates these functionalities with a catalog of intent-level tools to optimize tool calls and reduce parameter hallucination. This runtime model addresses the intersection of permissions, securely executing actions based on precise user and agent authorization, while providing a transparent, usage-based pricing structure. As the market divides between standalone gateways and full runtimes, enterprises must choose solutions that align with their specific security, compliance, and operational needs, with Arcade representing a mature option for regulated, multi-tenant deployments.

The new Model Context Protocol (MCP) release transitions from a stateful to a stateless model, eliminating session IDs and simplifying multi-user session management, which previously required complex session stores or sticky sessions. This change allows any server replica to handle any request, as clients now send all necessary information with each request, aligning with the stateless nature of REST APIs. While this simplifies the execution of simple tool calls by removing initialization steps, it necessitates adjustments in server logic for long-running tasks, as clients must now poll the server for updates instead of receiving automatic notifications. Arcade.dev's runtime supports both the old and new protocol versions, allowing for a gradual transition, and ensures consistent authorization and governance as new extensions are introduced. This shift to a stateless protocol aims to enhance scalability and ease of use, positioning MCP alongside the widely adopted REST standard.

Arcade.dev has introduced four new agent-optimized toolkits and several upgrades to enhance the functionality of various applications, allowing agents to perform tasks more efficiently and effectively. The Power BI toolkit, developed in response to customer needs, enables agents to interact with datasets and semantic models without accessing the Power BI portal, making data retrieval and validation seamless. Postman's toolkit facilitates comprehensive API management from building to monitoring, while Fireflies enhances meeting transcription and summarization capabilities. Insightly provides robust CRM integration to manage contacts and opportunities. Additionally, upgrades to tools like Excel, Gmail, Outlook, and Linear introduce new features to streamline workflows, improve security, and enhance user experience. These tools, running on Arcade's runtime with delegated user authorization, are tailored to the specific tasks agents perform, ensuring actions are limited to what the user is permitted to do.

Agent skills, which are essential for AI businesses, are portable workflows that can be executed by any employee, but their rapid proliferation raises safety concerns. Arcade.dev's SkillBench scores these skills across six dimensions, offering a letter grade from A to F. Despite scoring over 39,000 skills, 73.7% of them still possess risky safety scores, emphasizing that a passing grade does not ensure safety, as safety is determined by runtime properties. The tool boundary dimension, which dictates what a skill can do versus what it claims to do, reveals that 32.1% of skills have weak boundaries, indicating a lack of defined scope and permission checks. Popularity does not equate to quality, as 62% of the most popular skills are graded C or below, highlighting that trust and adoption are distinct metrics. The overarching message is that the trustworthiness of skills depends on runtime governance, emphasizing verification over mere popularity or passing grades.

The new release of the MCP protocol introduces a formalized track for extensions, which are additional capabilities that build on the core protocol's foundational tools and communication methods. This formalization aims to address the longstanding issue of fragmentation by categorizing extensions into official, experimental, and unofficial types, with official extensions requiring initial approval but allowing independent updates thereafter. A key change is the shift from a negotiated session state to a stateless protocol where client capabilities, including extensions, are communicated with every request, and server capabilities are exposed through a new discovery method. While this approach aims to keep the core protocol thin and stable, it introduces complexity for developers who must manage compatibility across different clients and versions of extensions. Arcade.dev offers a centralized solution to manage this complexity by acting as an MCP gateway that resolves client-server capability negotiations and maintains governance at runtime, ensuring consistent behavior regardless of the extensions supported by clients. Despite the benefits of a stable core and controlled updates, developers face the challenge of an expanding matrix of support requirements as more extensions are developed and adopted.

Traditional integration platforms like iPaaS and unified-API products have addressed static SaaS-to-SaaS data synchronization but fall short in dynamic environments where AI agents make non-linear decisions. These autonomous systems necessitate advanced integration layers that ensure dynamic authorization, stringent capability permissioning, and granular auditability to scale securely across enterprise environments. Choosing the appropriate platform is critical; it involves evaluating secure per-user delegated authorization, tool execution governance, audit logs, and pricing models over mere connector counts. Arcade offers a comprehensive runtime for multi-user agent deployments with strict security and governance, while platforms like Composio and Nango cater to individual use cases and prototyping, and unified APIs like Merge and Nango are ideal for continuous data syncs. iPaaS solutions remain suited for deterministic workflows without the complexities of dynamic agent actions. The overarching theme is that a secure, scalable AI agent deployment requires platforms that focus on robust governance, delegated authorization, and efficient task execution, avoiding the engineering burden of custom OAuth flows and API wrappers.

Connecting large language models (LLMs) to external systems has evolved into a standardized process utilizing open protocols such as the Model Context Protocol (MCP) and agent-to-agent (A2A) coordination to facilitate multi-user production agents. While protocol connectivity is largely resolved, the current scaling bottleneck lies in the quality of tools, which encompasses context efficiency, multi-user authorization, execution reliability, and audit capabilities. AI agent tool calling allows LLMs to interact with external systems by autonomously selecting and invoking tools based on natural language intent, but the transition from prototype to production requires more than just API wrappers; it demands agent-optimized tools with clear definitions, constrained parameters, and built-in failure guidance. The adoption of dynamic tool-loading, post-prompt delegated authorization, and robust security frameworks are essential for reliable, secure tool execution in multi-user environments. Solutions like Arcade.dev address these challenges by providing a secure, agent-optimized action runtime that decouples tool execution from models, offering over 8,000 pre-built tools and comprehensive security and governance features, thus enabling scalable, reliable, and secure deployment of AI agents in enterprise settings.

As companies transition from simply having an AI story to achieving tangible AI results, they are confronting the financial realities of AI implementation, illustrated by Uber's rapid expenditure of its AI budget and subsequent updates to its usage policies. This shift in focus towards practical results over theoretical potential indicates a maturing of the AI space, akin to previous technological advancements such as virtualization with VMware and cloud computing with EC2. The challenge lies in architecting AI agents efficiently to avoid excessive token costs, as poor design can significantly inflate expenses, demonstrated by Arcade.dev's research showing a stark contrast in token usage between different MCP toolkits. Companies that successfully navigate this phase will focus on optimizing AI architectures to control costs while enhancing productivity, understanding that ROI and value are not immediately measurable but evolve from well-designed systems.

Since the inception of the Model Context Protocol (MCP), contributions have focused on bridging text-based AI with actionable systems, emphasizing secure authentication and authorization mechanisms. A significant personal contribution was URL mode elicitation, which enhances secure tool authorization by facilitating direct user interaction in a secure browser, safeguarding sensitive data from exposure. The latest contribution involves clarifying how MCP clients should handle refresh tokens, drawing from established OAuth and OpenID Connect practices to ensure consistent behavior across the ecosystem. This is crucial for maintaining interoperability and a seamless user experience, as refresh tokens allow clients to renew access tokens without frequent user logins. The previous lack of explicit guidelines led to inconsistent implementations, but the current release addresses these gaps to support MCP's transition from demo stages to robust production use. This evolution ensures MCP's long-term viability and effectiveness in real-world applications, reinforcing its role as a powerful standard in enterprise environments.

The transition of the Model Context Protocol (MCP) from stateful to stateless sessions is aimed at addressing scalability challenges associated with running MCP servers for large-scale deployments, such as those involving millions of users. This change eliminates the need for session IDs, which complicate load balancing and server communication at scale. While the shift to stateless communication simplifies server operations and enhances stability by removing brittle session handling, it introduces a breaking change that necessitates significant rewrites for developers accustomed to the previous protocol. The benefits of this transition include improved scalability and reduced bug issues, but it also leads to temporary fragmentation as clients and servers adapt to the new protocol. Arcade.dev offers a solution by acting as an MCP gateway that supports both protocol versions, ensuring smooth transitions and maintaining critical controls such as authorization and policy enforcement independent of protocol changes. This evolution is expected to stabilize the ecosystem and enable more companies to deploy official MCP servers effectively.

On July 28, significant changes to the Model Context Protocol (MCP) will be introduced, requiring users to adapt promptly. Arcade.dev is providing resources to assist with this transition, including a comprehensive webinar hosted by Developer Advocate Mateo Torres. The webinar, titled "What Changes, What Breaks, and What You Need to Do About It," will take place on the release date at 10 AM Pacific and will cover essential updates regarding the protocol’s core, authorization, extensions, and deprecations. It aims to clarify the importance of the changes, distinguish between urgent and non-urgent adjustments, and guide teams on necessary tactical and strategic adaptations. Participants will also benefit from live demonstrations and a Q&A session, with the option to receive a recording if unable to attend.

Agentic AI has evolved through the introduction of "skills," which are essentially sets of markdown instructions that enable workflows to be easily shared and adopted across enterprises. Since their introduction by Anthropic in 2025, the number of published skills has grown significantly, but the rapid expansion has raised concerns about quality control. To address this, SkillBench was developed to assess and grade these skills based on six weighted dimensions, including safety, tool boundary, and workflow quality, among others. Safety is the most critical factor, accounting for 35% of the total score, as the potential for real-world business impact is significant. Of the 39,000 skills scored, 73% showed elevated safety risks, with 7,034 failing due to serious security issues. Despite these challenges, 20% of skills received high grades, indicating that improvements in tool boundaries and transparency can enhance overall quality. Users are advised to filter and evaluate skills carefully before implementation, while developers are encouraged to score and refine their skills using SkillBench to ensure safety and reliability in the evolving ecosystem of agentic AI.

In a week of significant developments in AI, companies like OpenAI, SpaceXAI, and Meta Superintelligence Labs have launched new models targeting the enterprise market, emphasizing the shift from consumer chat and reasoning benchmarks to end-to-end enterprise knowledge work. These models, such as OpenAI's GPT-5.6 paired with ChatGPT Work and SpaceXAI's Grok 4.5, demonstrate capabilities like transforming unstructured data into organized outputs across multiple platforms like Slack, Notion, and Microsoft 365. However, the real challenge for enterprises lies in closing the "actions runtime gap," which involves ensuring these AI models can scale from demos to production with robust security, execution, and governance frameworks. This involves solving issues related to the enforcement of permissions, the execution of actions across integrated systems, and the governance of agent activities. While these models show promise in transforming enterprise workflows, they currently lack the necessary infrastructure to integrate seamlessly with existing security and compliance systems, prompting the need for solutions like Arcade.dev that can provide a unified control plane for managing AI actions in enterprise environments.

The text discusses the limitations of vendor-native agents like Salesforce's Agentforce in automating cross-system workflows, emphasizing that such agents are confined to their own ecosystems and unable to effectively manage tasks that span multiple platforms. This constraint arises from the architecture of these systems, which are designed to deepen user dependency rather than facilitate seamless integration across diverse systems. The text argues that while vendors may develop MCP (multi-cloud platform) servers to expose their capabilities, this does not equate to solving the integration problem, as no single vendor owns the entire workflow that requires orchestration across various systems. Arcade.dev is introduced as a solution, offering MCP tools that focus on intent mapping rather than being confined to a single system's API, thus enabling reliable, end-to-end workflow automation. The text highlights the inefficiency and increased token consumption of poorly integrated systems, advocating for infrastructure that facilitates authentication and operation across different platforms.

AI engineering teams are transitioning from single-user demos to multi-user enterprise deployments, encountering challenges with authentication, which often fails first. While prototypes can function with shared service accounts, production agents interacting across various users and systems require delegated authorization, credential isolation, and strict policy enforcement to prevent risks such as credential drift and prompt injection attacks. The choice of platform depends on the agent's needs, such as executing governed actions, connecting to multiple tools quickly, or extending identity layers. Platforms like Arcade.dev provide a comprehensive solution with action runtime, delegated context, and audit logs, while others like Auth0, WorkOS, AWS AgentCore, Composio, Nango, and Merge cater to specific requirements like extending existing identity programs, AWS-native infrastructure, or rapid prototyping. Key elements for a secure production environment include two-identity modeling, delegated context, runtime policy hooks, and robust audit trails, ensuring actions are auditable and comply with enterprise standards.

Gauntlet is an innovative AI-driven system developed by Arcade.dev to enhance the efficiency of building and maintaining tools for AI agents, significantly reducing the time and effort required for tool development. The system leverages AI agents as both testers and developers, allowing them to explore tools like real users, identify bugs and issues, and iteratively improve the tools through a loop of testing and rewriting. This process, which can generate substantial volumes of code overnight, has already enabled the rapid creation and updating of toolkits, such as those for Google Slides and Twitter, transforming tasks that once took months into overnight achievements. While Gauntlet is still being refined, particularly in areas like automated OAuth app provisioning, it exemplifies how agentic AI can streamline development and improve the reliability and timeliness of critical customer-facing services such as Google Workspace and Microsoft 365.

In a groundbreaking incident, an AI-driven ransomware attack known as JADEPUFFER highlighted both the capabilities and limitations of autonomous agents in cybersecurity threats. The attack exploited a year-old vulnerability in a Langflow instance, a method previously documented and supposedly patchable, allowing the AI to infiltrate a company's system without human intervention, harvest sensitive credentials, and encrypt critical data. Remarkably, despite its advanced operational capabilities, the AI failed by losing the encryption key necessary for data recovery, underscoring a gap in current AI execution. The attack was orchestrated by a human who directed the AI, indicating that while AI can autonomously carry out complex tasks, it still relies on human intent. This incident emphasizes the need for robust security measures that control what AI agents can access and do, as traditional security assumptions are no longer sufficient against increasingly sophisticated AI threats.

Arcade.dev is designed to manage and mitigate the risks associated with both system failures and security breaches when agents interact with remote tools. It achieves this by handling tool-level failures through parallelized execution, automatic retries, and a clean classification of errors, preventing these issues from escalating into more significant problems. Security measures are enforced by encrypting credentials and scoping actions to individual users, thereby minimizing the impact of potential breaches. The platform's runtime availability can be tailored to user preferences, either by utilizing Arcade Cloud's managed service with built-in failover or by self-hosting to integrate with existing infrastructure for high availability. This robust architecture ensures that failures are contained and managed effectively, providing agents with the necessary tools and information to make informed decisions during workflows.

Arcade.dev provides a streamlined action runtime for integrating Antigravity with third-party services, addressing configuration sprawl and credential-management challenges associated with local MCP servers. It facilitates authenticated interactions with tools like Google Calendar, Notion, and Linear directly from the user's editor by managing downstream authorization, token storage, and execution state. Due to unreliable OAuth support in Antigravity, the guide recommends using Arcade Headers mode, which involves sending an Authorization header and an Arcade-User-ID for authenticated requests. This approach ensures secure and efficient tool execution without exposing credentials to local environments, leveraging Arcade's infrastructure for token vaulting and execution management. Until Antigravity enhances its OAuth offerings, Arcade Headers mode remains the most reliable integration method, enabling productive and secure connections to external services.

Arcade.dev offers a secure method for storing credentials by using an encrypted, per-user vault system where tokens are never exposed to the model, ensuring protection through a Key Management Service (KMS) at rest and Transport Layer Security (TLS) in transit. Users can decide whether the vault is managed by Arcade in their cloud infrastructure or self-hosted within their own environment, such as a private cloud or air-gapped network, which allows for full control over encryption keys and credential paths. This flexibility satisfies enterprise security concerns by ensuring that tokens are scoped per user, revocable, and never shared across accounts, allowing each action to be traced back to an individual user. This approach enables organizations to maintain stringent security standards, as it integrates seamlessly with existing VPN and Single Sign-On (SSO) systems, ensuring that the tokens remain secure while the agent operates efficiently without accessing sensitive credentials directly.

The text discusses the implementation and governance of background agents, focusing on their ability to execute tasks without direct human intervention while ensuring safety and compliance. It provides an example of a background support engineer agent that autonomously handles a bug report by creating a ticket, reproducing and fixing the bug, and drafting a pull request, all orchestrated through a series of automated actions triggered by an email. The governance model ensures that actions taken by the agent are authorized and compliant with policies by using a delegated authority system, where permissions are checked in real-time before tool execution, rather than relying on static authorizations. This system is designed to adapt to changes in user permissions and roles dynamically, ensuring that any unauthorized actions are blocked or require human approval. The approach emphasizes logging and traceability, allowing for a detailed audit trail of the agent's actions, which can be queried to ensure accountability. The layers of the stack, including the trigger, procedure, and governance, work together to allow the agent to function independently and securely, aligned with policies managed through configuration rather than relying on the agent's behavior.

The text discusses the distinction between APIs and MCPs, emphasizing that the common belief that every SaaS vendor will own its MCP server, similar to APIs, is flawed. While APIs function as service contracts detailing how a system operates and interacts, MCPs serve as intent contracts, focusing on what users aim to accomplish rather than the system's capabilities. This misalignment leads to inefficient agents that struggle in production, as they perform tasks slowly and with higher error rates. The text argues that MCPs should be designed around intents rather than being tied to specific vendors, which often results in more efficient, accurate, and faster performance. It highlights that an effective MCP server spans multiple vendors' APIs and is shaped by specific business needs rather than the vendor's product structure. The piece concludes by asserting that vendors cannot provide intent contracts for workflows that are tailored to individual businesses, suggesting that tools like Arcade.dev are designed to address this gap by focusing on intent contracts instead of simply wrapping APIs.

Arcade.dev provides a secure and efficient way to integrate Codex with third-party services like Google Calendar, Microsoft Word, and Linear by acting as an action runtime and routing gateway. By managing downstream token vaulting, OAuth authentication, and structured execution logs, Arcade eliminates the risks associated with local storage of service credentials, reducing configuration sprawl and enhancing tool reliability. The integration enables Codex to autonomously perform actions such as scheduling calendar events, creating documents, and managing project issues directly from the editor without exposing sensitive credentials to the Codex model context. This setup not only improves engineering efficiency but also ensures secure and reliable execution of authenticated actions by using Arcade's token management and execution infrastructure, thus avoiding common pitfalls like parameter hallucination and credential leaks associated with raw MCP tool wrappers.

Arcade.dev offers a seamless deployment solution for its software through one-click deploy options available on Microsoft Azure and Amazon Web Services (AWS) marketplaces, allowing customers to run Arcade within their own cloud environments without the hassle of manual provisioning. This approach ensures that organizations can maintain control over their data using familiar security protocols and governance policies, as Arcade integrates with existing identity providers and runs in isolated containers with minimal permissions. By utilizing existing cloud budgets, companies can streamline the adoption of Arcade without needing separate budget approvals or procurement processes. This deployment is designed to be consistent across both Azure and AWS platforms, providing enterprise support and service level agreements (SLAs) to accommodate custom configurations and ensure users are always on the latest version.

At the AI Engineer World's Fair, Arcade.dev showcased an innovative system for managing AI agents in production environments, emphasizing identity and authorization for user actions. The system allows users to call a number, input a PIN, and file GitHub issues under their account, highlighting the importance of per-user OAuth to ensure actions are attributed correctly. The setup involves five services: Vapi for voice calls, Inngest for workflow orchestration, Cursor for code writing, Arcade for user-specific authorization, and Cloudflare Workers for hosting. This framework addresses the challenges of shared bot tokens by using individual user identities to restrict agent capabilities, ensuring that actions are authorized based on the caller's entitlements. Additionally, the system incorporates governance, rate limiting, and durable orchestration to handle long-running tasks, such as code generation, while maintaining security boundaries. The approach extends beyond voice interfaces, applicable to any shared agent use case, underscoring the need for robust identity resolution and action governance.

The Model Context Protocol (MCP) enables OpenCode to trigger pipelines or interact with developer tools like Git directly from the editor but can lead to configuration and credential management challenges when adding more services. Arcade.dev offers a solution as an action runtime rather than just a routing gateway, providing OpenCode with agent-optimized tools through a single endpoint, enhanced by native OAuth for authentication and downstream token vaulting. By connecting OpenCode to Arcade, developers can streamline tool execution and reduce credential exposure, as Arcade handles token lifecycle management and execution logs, while maintaining user-bound gateway sessions. This setup improves reliability over native MCP configurations by keeping service credentials separate from the editor and reducing the complexity of tool calls. The guide explains how to configure OpenCode with Arcade, emphasizing the advantages of using OAuth-backed sessions to manage downstream service authentication and execution.

Background agents operate on a schedule or trigger without direct human intervention, creating valuable automation but posing security challenges, such as avoiding over-permissioned service accounts. Arcade.dev addresses these challenges by decoupling authorization from live sessions, allowing background agents to act under real, delegated user authority without human involvement at runtime. Unlike interactive agents requiring OAuth consent screens, background agents rely on Arcade's management of the entire OAuth lifecycle, ensuring tokens are securely stored and refreshed automatically, preventing failures due to expired credentials. Permissions are verified in real-time during execution using contextual access hooks tied to identity providers, ensuring that any changes in user roles or access rights are immediately enforced. When new authorizations are needed, the system issues a flexible authorization link for user completion, ensuring actions remain accountable and traceable through security information systems like SIEM via OpenTelemetry, maintaining a robust audit trail for every action performed by these agents.