How Claude managed agents changed what Prio can do in the background
Most AI assistants work in turns. You send a message, the AI responds, you send another. It's a conversation. That model works great for quick tasks — draft this email, summarize that thread, schedule this meeting.
But some tasks don't fit into turns. Researching a competitor takes 15 minutes of searching, reading, cross-referencing, and synthesizing. Triaging 50 emails while checking calendars and contact history involves dozens of steps. Preparing a meeting brief means pulling data from three different tools and weaving it together.
These are the tasks where you used to type a prompt, wait, get a partial answer, type another prompt, wait again, and eventually give up and do it yourself.
That changed when Anthropic released the managed agents API.
What managed agents actually are
A managed agent is an AI that runs a complete task from start to finish on Anthropic's servers. No turn-taking. No waiting for your next message. You describe what you need, and the agent works through it autonomously — searching the web, reading documents, calling tools, reasoning through problems — until the job is done.
The key difference from a regular API call: a managed agent has a session. It maintains state across dozens of internal steps. It can use tools — both built-in ones like web search and file operations, and custom ones that connect to your specific data. When it hits a custom tool call, the session pauses, your server executes the tool, sends the result back, and the agent continues.
This isn't a chatbot that happens to call a function. It's a runtime that executes complex work.
How we use it in Prio
We integrated managed agents into two core workflows: deep research and autonomous background tasks. Both are the kind of work that fundamentally doesn't fit into a chat turn.
Deep research
When you ask Prio to research something — a company, a market trend, a competitor's pricing — it used to run a simplified search-and-summarize pipeline. Useful, but shallow. The results read like a Google search summary because that's essentially what they were.
With managed agents, the research pipeline looks different. The agent receives your query along with your context — who you are, what company you're at, what you've been working on. Then it runs autonomously:
- Searches the web for relevant sources
- Reads full pages, not just snippets
- Cross-references findings against your email history and contacts
- Identifies gaps in its research and runs follow-up searches
- Synthesizes everything into a structured report with sources
The entire process takes 30 seconds to a few minutes depending on complexity. You see progress updates in real time — "searching for competitor pricing," "reading annual report," "synthesizing findings" — but you don't need to intervene. The agent handles the entire research loop.
The result is a markdown report with citations, not a chatbot response.
Autonomous background tasks
The second use case is broader. Sometimes you need Prio to do something that involves multiple tools and multiple steps. "Draft a follow-up email to everyone from yesterday's board meeting, referencing the action items we discussed" requires checking the calendar, finding the meeting, looking up attendees, checking your contact database for email preferences, and then drafting personalized emails.
In a chat model, this would be a back-and-forth. The agent would ask clarifying questions, show partial results, wait for confirmation at each step.
With managed agents, it runs in the background. The agent accesses your calendar, contacts, and email through custom tools, does all the coordination internally, and surfaces the final result — draft emails queued for your approval.
You don't monitor the process. You get pinged when it's done.
The custom tool bridge
This is where the architecture gets interesting. A managed agent on Anthropic's servers can't read your Gmail. It doesn't have your calendar token. It can't query your contact database. That data lives in Prio's backend.
So we built a bridge. When the managed agent needs user data, it calls a custom tool — search_emails, read_email, search_calendar, search_contacts, list_tasks. The session pauses. Prio's server receives the tool call, executes it against the user's connected integrations (with their OAuth tokens), and sends the result back to the agent. The agent continues working.
This means the managed agent has the reasoning capability of Claude running autonomously, combined with access to your actual data. It can search your inbox, check your calendar, and look up contacts — all within a single task execution, without any user interaction.
For write operations — sending emails, creating tasks — the agent queues these as pending actions. You approve them before anything gets sent. The approval layer from regular Prio chat carries over to managed agent tasks.
What users see
From the user's perspective, managed agents are invisible infrastructure. You ask Prio to research something or handle a complex task. An activity card appears showing progress. When it's done, you get the result.
No new UI to learn. No mode to switch to. The system decides whether a task needs a managed agent or can be handled through regular chat — based on complexity, the number of tools involved, and whether the task benefits from autonomous execution.
If managed agents aren't enabled for your account (we're rolling this out gradually via feature flags), the same tasks route through alternative engines. The interface is identical either way.
Why this matters beyond Prio
The managed agents pattern solves a problem every AI product is hitting right now: chat is too slow for real work.
The chat paradigm made sense when AI was primarily a writing tool. You prompt, it generates, you iterate. But as AI gets access to real tools — email, calendars, databases, APIs — the bottleneck becomes the human in the loop. You're the slowest part of the system, clicking "continue" and "yes, do that" through a multi-step process.
Managed agents flip the model. The human defines the goal and reviews the output. The agent handles execution. It's closer to how you'd work with a competent human assistant — "prepare the board meeting brief" and come back to a finished document, not "first check the calendar... now look up the attendees... now pull their recent emails..."
What comes next
We're at the early stage of this pattern. The current version handles research and multi-step operational tasks. But the same architecture extends to:
Proactive agents. Instead of waiting for your prompt, a managed agent could run every morning at 7am — triage your inbox, prepare your daily brief, flag anything urgent from overnight, and have it all ready when you open Prio.
Long-running monitors. An agent that watches your email for a specific contract to come through, checks the terms against your requirements, and alerts you only when it arrives — with a summary.
Multi-agent coordination. One agent handles email triage while another prepares meeting briefs while a third monitors your GitHub notifications. Each runs independently, with their own sessions and context, but all connected to your data.
The foundation is there. The managed agents API gives us a runtime that handles tasks to completion, custom tools give us the data bridge, and the approval layer keeps you in control.
The bottom line
AI assistants that only work when you're actively chatting are hitting a ceiling. The real productivity gains come from AI that works in the background — researching, coordinating, preparing — and only interrupts you when there's something to review or decide.
Managed agents are how we're getting there. Not by making the chat faster, but by making the chat optional for the tasks that don't need it.
Prio uses Claude managed agents to handle deep research and autonomous tasks. The result is an AI assistant that works while you don't. Try it free.