You give an agent a real job. Reconcile a month of invoices, migrate a project across systems, work through a backlog of tickets. It starts strong, but then you come back an hour later to find it stopped almost as soon as you left, waiting for you to click a link and authorize the next tool.
As part of our effort to move AI agents into real world work, Arcade.dev now lets your agent line up every auth it needs before it starts with bundled pre-authorization.
When an agent knows it will touch several services to finish your request, it asks Arcade for all of them at once and gets back a single approval link per service. Each link covers only what this job actually needs, nothing more.
That means you now approve each service one time, up front, instead of a new consent screen surfacing every few steps as the agent works, enabling your agent to run to the end of a job without being blocked by an auth request.
Agents already look ahead. Now authorization does too.
Modern agents plan before they act. Give one an instruction and it maps out the tools it expects to reach for, often pulling the whole set into context before it runs a single step. Claude Code does this. So does Cowork. The planning side of the equation is set.
The speedbump came along with reactive authorization. Authorizing a tool only when the agent actually invoked it meant approvals scattered across a task, whenever each tool happened to come up.
Now as soon as the agent lays out the tools it plans to use, it hands that set to Arcade and gets back one bundled authorization link per service. Ten Google tools become one Google approval, not ten. You clear them together at the start, so far fewer OAuth flows stand between you and a running agent.
Pre-auth doesn’t mean unsafe
Approving early is not the same as handing an agent a blank check. Everything that makes Arcade an actions runtime still applies. Each tool is authorized for the specific user, against the scopes it’s actually allowed, and every action the agent takes still runs through Arcade’s per-action enforcement in the moment.
Each authorization is demand-scoped, one approval per service, covering exactly the tools this job calls for and nothing else. That’s the Principle of Least Privilege, applied automatically.
That distinction matters, because the easy way to avoid the checkpoints that slow down a job would be to hand the agent broad standing access and stop asking questions. Arcade does the opposite. You clear the exact authorizations this task needs, no more, and the actions runtime keeps evaluating each action for the right user, on the right resource, as it happens.
The stalled work disappears, not the governance.
Why this matters most for long-running work
For a quick back-and-forth job you’re watching the whole time, a mid-task auth prompt is a minor annoyance. You click it and move on. The cost shows up on the long jobs, the ones you start precisely so you can go do something else.
Those are the tasks where a single missed click is expensive. You kick off a 40-minute run, close the laptop, and the agent stops four minutes in on an authorization you never saw. The time you were trying to save is gone, and you don’t find out until you come back. Clearing authorizations up front is what lets you actually walk away. The agent has what it needs before you leave, so the only thing left to do is let it work.
The short version
Agents plan their tools up front, and now Arcade handles authorization the same way. You approve everything the task needs in one pass at the start, the actions runtime keeps enforcing every action for the right user in bounds, and long-running work stops stalling on an approval you’re not there to give. Send the prompt, pre-authorize the bundled approvals, and let it run.
Pre-authorize once, up front. Then walk away.
