The conversation around AI in healthcare has been dominated by chatbots. Ask a question, get an answer. Upload a scan, get a classification. These are useful tools, but they represent the shallow end of what AI can do in clinical environments.
The real transformation is happening one layer deeper: autonomous AI agents that can plan, execute multi-step workflows, coordinate across systems, and make decisions under uncertainty — all without a human clicking “next” at every step.
In 2025 and 2026, we have watched the rise of Manus, Devin, Claude Code, and OpenAI Operator — autonomous agents that can browse the web, write and execute code, manage files, and orchestrate complex tasks. The question healthcare leaders should be asking is not “when will this come to healthcare?” but rather “what needs to be true before it can?”
This article examines the autonomous agent revolution through a healthcare lens, explores what current AI benchmarks actually measure (and what they miss), and lays out IntelMedica’s approach to building safe, effective multi-agent systems for clinical environments.
The Autonomous Agent Revolution
An autonomous AI agent is fundamentally different from a chatbot. Where a chatbot responds to a prompt, an agent pursues an objective. It decomposes a goal into sub-tasks, selects tools, executes actions, observes results, and adapts its plan accordingly. This is the ReAct (Reasoning + Acting) paradigm, and it has moved from research papers to production systems at remarkable speed.
Consider what today’s frontier agents can do:
- Manus can take a high-level business objective and autonomously research, plan, and execute multi-step workflows across web services, databases, and APIs.
- Devin can receive a GitHub issue, analyze the codebase, write a fix, run tests, and submit a pull request — all without human intervention.
- Claude Code operates as a full software engineering agent, navigating codebases, spawning sub-agents, and coordinating parallel workstreams.
- OpenAI Operator can navigate web interfaces, fill forms, and complete transactions on behalf of users.
These agents share a common architecture: a reasoning core (typically a large language model), a set of tools (code execution, web browsing, file I/O, API calls), and a planning loop that persists across multiple steps. They are not doing one thing well — they are doing many things sequentially and in parallel to achieve a complex outcome.
Why Healthcare Needs Autonomous Agents
Healthcare is, arguably, the industry most in need of autonomous agents and simultaneously the one most hostile to their deployment. The reason for the need is simple: healthcare workflows are brutally complex.
Consider a prior authorization request. A clinician decides a patient needs an MRI. What follows is a cascade of steps that no single chatbot can handle:
- Verify the patient’s insurance eligibility and plan details.
- Determine if the specific procedure requires prior authorization for this payer.
- Gather the relevant clinical documentation — notes, lab results, imaging history.
- Map the clinical rationale to the payer’s medical necessity criteria.
- Complete the payer-specific authorization form (which differs by insurer).
- Submit the request through the correct channel (portal, fax, phone, EDI).
- Track the response, handle requests for additional information, and appeal denials.
Each step requires accessing a different system, applying domain-specific knowledge, and making judgment calls. A chatbot that answers “what ICD-10 code should I use?” is helpful. An agent that executes steps 1 through 7 autonomously is transformative. The American Medical Association estimates that prior authorization costs the U.S. healthcare system over $35 billion annually in administrative overhead. Autonomous agents that can handle even 60% of this workflow represent enormous value.
But the need extends beyond prior authorization. Clinical documentation, referral coordination, medication reconciliation, quality reporting, billing and coding — healthcare is riddled with multi-step, multi-system workflows that consume clinician time and generate errors. These are precisely the workflows where autonomous agents excel.
Current Benchmarks and Their Limitations
Before deploying autonomous agents in healthcare, we need to know how good they actually are. This is where benchmarks come in — and where the story gets complicated.
The AI industry has developed several benchmarks for evaluating agent capabilities:
SWE-bench measures an agent’s ability to resolve real GitHub issues in open-source repositories. Top agents now solve over 70% of these tasks. SWE-bench tells us that agents can understand codebases, reason about bugs, and produce working fixes. It tells us nothing about clinical reasoning.
GAIA (General AI Assistants) evaluates multi-step reasoning tasks that require web browsing, calculation, and tool use. It tests whether an agent can plan and execute complex research tasks. The clinical relevance is tangential — GAIA tasks resemble literature review more than patient care.
HumanEval and MBPP measure code generation accuracy. Useful for evaluating the coding capabilities of agents that will interact with healthcare APIs, but irrelevant for clinical decision-making.
MedQA and MedPaL are medical knowledge benchmarks, but they evaluate chatbot-style question answering, not autonomous workflow execution. Getting a board-exam question right is not the same as navigating a payer portal to submit an authorization.
The gap is significant. There is no widely accepted benchmark that evaluates an autonomous agent’s ability to:
- Execute a multi-step clinical workflow end-to-end.
- Handle incomplete or contradictory information (which is the norm in clinical data).
- Interact with real-world healthcare systems (EHRs, payer portals, lab systems) that have unpredictable interfaces.
- Fail safely — recognize when it is out of its depth and escalate to a human.
- Maintain HIPAA compliance throughout an autonomous workflow.
This is not a minor oversight. It means that when a vendor tells you their agent scores 72% on SWE-bench, you have essentially zero information about how it will perform on a prior authorization workflow.
IntelMedica’s Approach to Healthcare-Specific AI Evaluation
At IntelMedica, we are building evaluation frameworks that test what actually matters for healthcare autonomous agents. Our approach is structured around three pillars:
Workflow Completion Benchmarks
We construct end-to-end workflow scenarios using de-identified clinical data and simulated healthcare system interfaces. An agent is given a goal — “submit a prior authorization for this patient’s cardiac MRI” — and evaluated on:
- Task completion rate: Did the authorization get submitted correctly?
- Step accuracy: Were the intermediate steps (eligibility verification, documentation gathering, form completion) executed correctly?
- Recovery from errors: When a step fails (portal timeout, missing document), does the agent recover gracefully or spiral?
- Time to completion: How does agent performance compare to a trained human performing the same workflow?
Safety and Escalation Testing
We deliberately inject failure conditions into workflows:
- Ambiguous clinical data that could support multiple interpretations.
- System outages that require fallback procedures.
- Edge cases where the correct action is to stop and ask a human.
- Scenarios where proceeding would violate HIPAA or clinical safety norms.
An agent that completes 95% of workflows but fails to escalate appropriately in the remaining 5% is more dangerous than one that completes 80% and reliably escalates the rest. We weight safety metrics heavily.
Longitudinal Consistency
Healthcare workflows are not one-shot tasks. A prior authorization may span days. A care coordination workflow may span weeks. We evaluate whether agents maintain context, track state changes (new lab results, updated insurance information), and adapt their plans accordingly.
Safety Constraints: Why Healthcare Agents Need Guardrails
The autonomous agent community has largely focused on capability — making agents that can do more. In healthcare, the harder problem is constraint — making agents that reliably will not do certain things.
Our guardrail architecture operates at multiple levels:
Action-level guardrails prevent specific dangerous operations. An agent cannot modify a patient’s medication list, sign a clinical order, or transmit PHI to an unauthorized endpoint. These are hard constraints, not suggestions. They are enforced at the tool level — the agent literally cannot call a function that performs a prohibited action.
Workflow-level guardrails define the boundaries of autonomous operation. For prior authorization, an agent can gather documents, fill forms, and draft submissions — but a human must review and approve before submission. The level of autonomy is configurable per workflow and per organization.
Confidence-based escalation requires agents to output a calibrated confidence score at each decision point. When confidence drops below a threshold (which varies by the clinical severity of the task), the agent pauses and escalates to a human reviewer. Getting calibration right is an active area of research for us.
Audit logging captures every action, every tool call, every decision point, and every piece of data accessed. In healthcare, you do not get to say “the AI did it.” You need a complete, auditable trace of what the agent did and why.
The Multi-Agent Architecture
Single-agent architectures hit a ceiling quickly in healthcare. The domain knowledge required is too broad, the system integrations too varied, and the risk too high for a monolithic agent.
IntelMedica uses a multi-agent architecture with clear role separation:
The Orchestrator is the top-level agent. It receives a task, decomposes it into sub-tasks, assigns them to specialized agents, monitors progress, and synthesizes results. The orchestrator does not interact with clinical data directly — it operates at the workflow level.
Clinical Agents are specialized for specific clinical domains. A cardiology agent understands cardiac imaging protocols and payer criteria for cardiac procedures. A pharmacy agent understands drug interactions, formulary rules, and prior authorization requirements for medications. These agents are fine-tuned or prompt-engineered with domain-specific knowledge.
Integration Agents handle the messy reality of healthcare IT. An EHR agent knows how to extract data from Epic via FHIR APIs. A payer agent knows how to navigate specific insurance portals. A fax agent (yes, fax — healthcare still runs on fax) knows how to generate, send, and track faxed documents.
Documentation Agents handle the clinical documentation burden. They generate notes, letters, and forms from structured data and clinical context, always in a style and format appropriate for the specific use case (patient-facing vs. payer-facing vs. clinical).
Review Agents act as the quality gate. Before any agent output is finalized, a review agent checks for clinical accuracy, regulatory compliance, and internal consistency. This is the multi-agent equivalent of code review — no agent’s work ships without peer review.
This architecture provides several advantages:
- Specialization: Each agent can be optimized for its specific domain without compromising generality.
- Isolation: A failure in one agent does not cascade to others. If the payer agent cannot reach a portal, the clinical agent’s documentation is unaffected.
- Auditability: The orchestrator’s task decomposition creates a clear record of which agent did what and when.
- Scalability: New agents can be added for new domains or integrations without restructuring the system.
Case Study: Multi-Agent Prior Authorization
To make this concrete, here is how our multi-agent system handles a prior authorization workflow:
Step 1: Task Intake. A clinician orders an MRI of the lumbar spine for a patient with chronic low back pain. The order triggers the orchestrator, which identifies this as a prior authorization workflow.
Step 2: Eligibility Verification. The orchestrator dispatches the payer integration agent, which queries the patient’s insurance eligibility via the X12 270/271 EDI transaction. The agent confirms the plan is active and identifies the specific prior authorization requirements for imaging.
Step 3: Clinical Documentation Gathering. The EHR integration agent extracts the relevant clinical documentation — the patient’s history of low back pain, previous conservative treatments (physical therapy, NSAIDs), recent exam findings, and any prior imaging results. This data is structured and passed to the clinical agent.
Step 4: Medical Necessity Determination. The clinical agent evaluates the gathered documentation against the payer’s medical necessity criteria (typically InterQual or MCG guidelines). It identifies any gaps — for example, if the payer requires documentation of six weeks of conservative treatment and the chart only documents four weeks, the agent flags this and suggests the clinician document the additional treatment history.
Step 5: Form Completion. The documentation agent generates the prior authorization request, mapping clinical findings to the specific fields and codes required by the payer. It selects appropriate ICD-10 and CPT codes, writes the clinical narrative, and attaches supporting documentation.
Step 6: Human Review. The completed authorization is presented to a staff member for review. The agent highlights any areas of uncertainty and provides a confidence score for the overall submission. The human can approve, modify, or reject.
Step 7: Submission and Tracking. Upon approval, the payer integration agent submits the authorization through the appropriate channel. It then monitors for responses, handles requests for additional information by looping back to the clinical agent, and tracks the authorization to resolution.
In our testing, this multi-agent workflow reduces prior authorization processing time from an average of 45 minutes of staff time to under 8 minutes, with the majority of that time spent on the human review step. The agents handle the data gathering, cross-referencing, and form completion that previously consumed the bulk of staff effort.
The Trust Gap
Despite the technical capabilities, there is a significant trust gap between what autonomous agents can do and what healthcare organizations will allow them to do. This gap is rational, not irrational.
Healthcare decisions have consequences that software bugs do not. A misclassified image in a social media app is an inconvenience. A misclassified finding in a radiology report can lead to a missed diagnosis. The stakes demand a higher bar for trust.
Building trust requires three things:
Transparency. Healthcare organizations need to understand what the agent is doing, why it is doing it, and how confident it is. Black-box agents will not gain adoption in clinical settings, regardless of their accuracy metrics. Every agent decision must be explainable in terms that a clinician can evaluate.
Incremental autonomy. Start with low-risk, high-volume workflows where the agent’s decisions can be fully reviewed. Prior authorization is a good starting point because the consequences of errors are administrative, not clinical. As the system demonstrates reliability, autonomy can be extended to higher-risk workflows with appropriate safeguards.
Clinical validation. Peer-reviewed evidence of safety and efficacy, not just vendor benchmarks. IntelMedica is committed to publishing our evaluation results and collaborating with academic medical centers on independent validation studies.
Regulatory Considerations
Autonomous AI agents in healthcare operate in a complex regulatory environment:
FDA. If an agent makes or supports clinical decisions, it may be classified as a Software as a Medical Device (SaMD) under the FDA’s regulatory framework. The FDA’s 2023 guidance on Clinical Decision Support software clarifies which functions require premarket review. Agents that perform administrative tasks (prior authorization, scheduling) generally fall outside FDA jurisdiction, while those that interpret clinical data or recommend treatments may require clearance or approval.
HIPAA. Any agent that accesses, processes, or transmits Protected Health Information must comply with HIPAA’s Privacy and Security Rules. This has implications for agent architecture — agents must use minimum necessary access, maintain audit trails, and ensure that PHI is not retained beyond what is needed for the task. For multi-agent systems, each agent must be individually compliant, and inter-agent communication must be secured.
CE Marking (EU). Under the EU Medical Device Regulation (MDR) and the AI Act, autonomous clinical agents face classification requirements and mandatory conformity assessments. The AI Act’s risk-based framework classifies most healthcare AI as “high-risk,” requiring conformity assessments, ongoing monitoring, and human oversight provisions.
State Regulations. Many U.S. states have additional requirements for AI in healthcare, including transparency mandates, bias testing requirements, and restrictions on automated decision-making in clinical contexts.
IntelMedica’s architecture is designed with regulatory compliance as a first-class concern, not an afterthought. The multi-agent design naturally supports the separation of administrative and clinical functions, minimum necessary access controls, and comprehensive audit logging that regulators require.
What Comes Next
The autonomous agent revolution in healthcare is not a question of “if” but “when” and “how.” The technology is maturing rapidly. The benchmarks are catching up, slowly. The regulatory frameworks are taking shape.
The organizations that will lead this transition are the ones investing now in:
- Healthcare-specific evaluation frameworks that test what actually matters.
- Multi-agent architectures that provide specialization, isolation, and auditability.
- Safety-first design that earns trust through transparency and incremental deployment.
- Regulatory expertise that treats compliance as an enabler, not an obstacle.
At IntelMedica, we are building all of these. The chatbot era was the proof of concept. The autonomous agent era is the product.
IntelMedica is building AI-native healthcare infrastructure. If you are a healthcare CTO, clinical informaticist, or engineering leader interested in autonomous agent architectures, we would like to hear from you. Visit intelmedica.com to learn more.