AI Agent Trust & Governance
Arcade pricing: how do I estimate monthly cost from tool executions, user challenges, and workers?
8 min read
Most teams first hit Arcade’s pricing questions the moment they move from a weekend agent prototype to “we’re wiring this into Gmail and Slack.” The good news: Arcade’s pricing is predictable once you break it into three levers—tool executions, user challenges, and workers—and the free included amounts on each plan.
Quick Answer: For most early-stage agents, you’ll stay within the free Hobby tier. As you scale, estimate monthly cost by projecting: (1) how many user challenges you’ll trigger, (2) how many standard vs. pro tool executions your agents will run, and (3) how many Arcade‑hosted workers you’ll keep online. Anything beyond the included amounts bills at simple per‑unit rates.
Frequently Asked Questions
How is Arcade pricing structured across plans?
Short Answer: Arcade is usage-based: each plan includes a free quota of user challenges, standard tool executions, pro tool executions, and hosted workers, with clear per‑unit prices once you exceed those included amounts.
Expanded Explanation:
Arcade is the MCP runtime between AI and action, so pricing tracks the things that actually cost infrastructure: authentication flows (“user challenges”), tool executions (standard vs. pro), and workers (MCP servers) that stay online to serve your agents. You can start on the free Hobby tier, grow into Growth for small production workloads, and move to Usage or Enterprise when you need scale, governance, and dedicated infrastructure.
Instead of charging per seat or per agent, Arcade charges for what your agents actually do:
- How often they authenticate users into services (user challenges)
- How often they call tools (standard vs. pro)
- How many Arcade-hosted workers stay up, and for how long
Self-hosted workers are free; you only pay for Arcade-hosted capacity and overages beyond your included bundle.
Key Takeaways:
- Plans are differentiated by included usage, not by feature-gating core agent capabilities.
- You pay for actual usage: user challenges, tool executions, and Arcade‑hosted worker hours.
How do I estimate monthly cost based on my agent’s workflow?
Short Answer: Map your agent’s typical session into counts of user challenges and tool calls per user per month, multiply by your expected number of users, then layer in any always‑on Arcade‑hosted workers.
Expanded Explanation:
The trick is to translate “what my agent does” into “how many units it consumes.” A “unit” in Arcade’s pricing terms is:
- A user challenge when a user authorizes or reauthorizes access to a service.
- A standard tool execution when your agent calls a typical MCP tool like
Gmail.ListEmails,Google.CreateEvent, orSlack.PostMessage. - A pro tool execution when your agent calls more complex or infrastructure-heavy tools (e.g., tools that orchestrate long-running workflows or heavy evaluations).
- An hour of an Arcade‑hosted worker (MCP server) running 24/7.
Once you know the per‑user behavior of your agent—how often it logs into Google on behalf of a user, how many emails it sends per week, how often it posts to Slack—you can multiply that out across users to get a realistic monthly cost.
Steps:
- Sketch a typical user flow.
Example: “When a sales rep says ‘summarize my inbox and draft follow-ups,’ the agent will: (a) authenticate Gmail once, (b) list 50 emails, (c) send 5 drafts.” - Assign Arcade units to each step.
- First Gmail connection: 1 user challenge
- Listing emails: 1 standard tool execution (
Gmail.ListEmails) - Sending each draft: 5 standard tool executions (
Google.SendEmail)
- Scale by frequency and users.
If a rep runs that once per day, 20 business days per month, and you have 10 reps:- User challenges: still ~1 per user (most auth is long‑lived) → ~10/month
- Standard tool executions: (1 + 5) × 20 × 10 = 1,200/month
Compare these against your plan’s included amounts to estimate cost.
What’s the difference between standard and pro tool executions in pricing?
Short Answer: Standard tool executions cover typical MCP tools with modest infra cost; pro tool executions are reserved for advanced tools that are more expensive to run, and they’re billed at a higher per‑call rate.
Expanded Explanation:
Arcade is designed so you don’t pay pro pricing for every simple API call. Most of your agent’s activity will be standard tool executions: listing emails, creating calendar events, posting Slack messages, updating CRM records. These are optimized for reliability and cost.
Pro tool executions are for “heavy” operations where the runtime needs more compute, storage, or orchestration—think complex evaluations, large data processing, or tools that coordinate multiple backend calls over time. They have a higher per‑unit price, but they’re kept separate so that typical agents aren’t silently paying for premium infrastructure when all they do is send emails.
Mechanically, both standard and pro tools look the same to your agent and your MCP client. The difference is behind the scenes: how the runtime executes them and how they’re metered.
Comparison Snapshot:
- Option A: Standard tool executions
- Typical tools like
Gmail.ListEmails,Google.CreateEvent,Slack.PostMessage - Lower per‑call cost, most usage falls here
- Typical tools like
- Option B: Pro tool executions
- Advanced tools with higher infrastructure cost
- Higher per‑call cost, smaller share of total calls
- Best for:
- Standard tools: day‑to‑day agent workflows at scale
- Pro tools: “power tools” where extra compute is worth it for the outcome
How do Arcade-hosted workers impact my monthly bill?
Short Answer: Arcade-hosted workers (MCP servers) are billed by server‑hour once you go beyond the included workers; self-hosted workers are free.
Expanded Explanation:
Workers are where your tools live. When you run arcade deploy, you’re spinning up MCP servers that the runtime uses to execute tools like Google.SendEmail and Salesforce.UpsertRecord. You can run these workers in your own environment (self-hosted) or let Arcade host them.
Each plan includes a baseline:
- Hobby: 1 free Arcade-hosted worker and 5 self-hosted workers
- Growth: “Everything in Hobby, scaled up,” plus the ability to add more Arcade-hosted workers at $0.05 per server-hour
- Usage/Enterprise: Unlimited self-hosted workers and unlimited Arcade-hosted workers at $0.05 per server-hour, plus tenant isolation, RBAC, SSO/SAML, and audit logs at the Enterprise level
If you spin up an Arcade-hosted worker and leave it running 24/7, that’s roughly:
- 1 worker × 24 hours × ~30 days = 720 server-hours / month
At $0.05 per server-hour, that’s $36/month per always-on Arcade-hosted worker (beyond what’s included). You can also scale workers up/down or rely heavily on self-hosted workers to keep Arcade-hosted usage small.
What You Need:
- A rough count of how many distinct MCP servers you’ll run and whether they must be Arcade-hosted.
- An estimate of how many hours per month each Arcade-hosted worker will stay online (e.g., 24/7 production vs. on-demand dev/staging).
How do user challenges affect cost as I add more users and integrations?
Short Answer: Each “user challenge” is a scoped authentication event into a service; you pay a small fee per challenge after the included quota, so most of your spend will still come from tool executions, not auth.
Expanded Explanation:
When your agent needs to act as a real user in Gmail, Slack, Salesforce, or GitHub, it kicks off an OAuth or IDP flow. In Arcade terms, that’s a user challenge: the user is challenged to authorize the agent with clear scopes. This is how Arcade enforces user-specific permissions and “zero token exposure to LLMs.”
Plans include:
- Hobby: 100 user challenges into services included
- Growth: 600 user challenges included, then $0.05 each
- Usage: 600+ user challenges included, then $0.05 each (scaled up for higher volume)
- Enterprise: custom volume pricing
The key: user challenges are typically infrequent. OAuth tokens are long-lived and automatically refreshed behind the scenes, so you’re not paying a challenge every time the agent sends an email. You primarily see challenges on:
- Initial connection to a service per user (e.g., “connect my Google account”)
- When scopes change or permissions are tightened
- Infrequent reconsent events
So even if you have 1,000 users, you won’t see 1,000 challenges per day. You’ll see bursts when teams adopt a new integration, then low steady-state usage.
Why It Matters:
- Most of your cost scales with what the agent does (tool executions), not how often users reauthenticate.
- Security isn’t a hidden tax: Arcade’s scoped OAuth and IDP integration are wrapped in simple per-challenge pricing.
Quick Recap
To estimate monthly cost on Arcade, ignore “AI hype” and look at three concrete knobs: user challenges, tool executions, and worker hours. Sketch how your agent actually behaves—how often it authenticates users, how many tool calls it makes per workflow, and how many MCP servers you need running 24/7. Compare those numbers to the included amounts on Hobby, Growth, Usage, or Enterprise, and then apply the per‑unit overage rates. For most teams, early prototypes stay fully within Hobby; steady production workloads land comfortably in Growth or Usage, with Enterprise reserved for dedicated infrastructure, tenant isolation, RBAC, SSO/SAML, and audit trails.