The Third Leading Cause of Death is Preventable

This is part four in a five-part series diving into the Amigo Cognitive Architecture. We’ve already covered Functional Memory, Context Graphs, and Dynamic Behaviors. In our final post, we’ll explore the Agent Core.

Medical errors are the third leading cause of death in the United States. It's a troubling statistic, but not a surprising one when you consider the interdependent nature of the healthcare system. Healthcare is built upon millions of everyday actions that depend on long chains of people, systems, and handoffs. In an environment this complex, mistakes in execution are inevitable.

As clinical AI agents take on more consequential roles in delivering care, they inherit the same underlying reality. This raises an uncomfortable question for anyone building or evaluating healthcare AI: if clinical agents will inevitably make mistakes, how do we make them safe?

Smarter Doesn’t Mean Safer#

The intuitive answer would be to simply make the agents smarter, but reasoning and executing are different problems. More advanced models can help agents make better decisions, but intelligence alone can’t prevent errors in execution. This is also true for human clinicians. A seasoned physician might know exactly which lab tests a patient needs and still occasionally input the wrong code in the EHR.

Instead of relying on an agent to take on tasks with unbounded complexity at a zero-percent error rate, the safest approach is to design systems that:

1. Outline precisely how each type of action should be performed
2. Include safety nets to minimize harm should an error occur

In healthcare, this is the difference between a recoverable mistake and a preventable death. Our thesis is simple: in order for clinical agents to perform actions safely, every workflow must be purpose-built and safe to fail.

This is the principle behind Amigo Actions, an execution layer within Amigo’s cognitive architecture that ensures all clinical workflows run in a controlled environment, creating a safer way for our agents to perform patient-facing work.

How Do Agents Perform Actions?#

An AI agent is a software program that can think, make decisions, and perform tasks. In a clinical setting, an agent might retrieve lab results, provide care instructions, or send follow-up reminders. To complete these tasks, agents call on tools (APIs), which are pieces of code that carry out specific actions.

Agents are being used to solve increasingly complex problems across industries, resulting in a need to integrate with a progressively larger set of tools over time. In response to this, Model Context Protocol (MCP) was introduced as a universal “tool language” that all agents can speak, allowing them to walk up to any compatible tool provider and ask for different services.

MCP is useful as a communication protocol that standardizes how an agent can ask for information, but it doesn’t govern how that request is carried out. There’s nothing that specifies where the code runs, who sees the data, or what happens if something fails.

Most off-the-shelf agent solutions focus on connecting agents to tools via MCP. This is a reasonable approach for low-stakes use cases where a failed action results in a bit of wasted time, but healthcare is different. Even a partial failure can have a direct human cost. If a clinical agent is given access to a tool to update prescriptions, it may start using it in an inconsistent manner. And worse, if it crashes in the middle of performing the action, the patient could end up with a corrupted file or partial record that omits crucial information.

Safety Lives in the Substrate#

That’s why we built Actions, an execution layer or substrate that governs how tasks are carried out. If MCP is a language that agents can use to make requests, a substrate is the environment in which those requests get executed.

You can think of each Action as a sterile single-use operating room. Each Amigo agent is equipped with a unique set of these “operating rooms” that are purpose-built for each type of action it is allowed to perform. They are specifically scoped to handle tasks that need to be deterministic and exact, without the unpredictability of relying on an AI model to figure it out.

After each operation, the operating room is reset completely. This design ensures that if something goes awry mid-procedure, the impact is self-contained and can be reversed or corrected without affecting the rest of the hospital. This prevents partial failures, acting as an essential failsafe for healthcare applications.

By contrast, a typical MCP-based setup relies on whatever environment the agent happens to be running in. There’s no guarantee of how or where an action is carried out, who has access to the data, or if the results can be undone. It’s the difference between a high-tech surgical suite and a hospital with no oversight or standards for keeping records. In one, all of the tools are neatly laid out and your chart is meticulously kept up to date. In the other, the doctor has already forgotten your name and is bringing in the next patient before they’ve had a chance to wash their hands.

The Anatomy of an Action#

We designed Actions to be atomic, ephemeral (or temporary), auditable, scalable, and deterministic. In a nutshell, this means that each time an agent needs to perform a task, we spin up a fresh, isolated workspace with only the resources and permissions it needs. Once the task is done, the workspace self-destructs and any sensitive data is scrubbed clean.

Each of these properties play a specific role in keeping agent operations safe and predictable.

• Atomic: Each Action either completes fully or fails cleanly so no partial or half-finished task can corrupt patient records or leave clinical workflows incomplete.
• Ephemeral: Every Action runs in an isolated environment that gets torn down and wiped clean after use, so no sensitive data persists once the task is finished.
• Auditable: Every Action is logged, generating a paper trail of what was done, when, and by which agent. This visibility allows teams to review activity, trace errors, and roll back to previous versions when needed.
• Scalable: Actions can expand from a single request to thousands running in parallel, all governed by the same substrate. This ensures consistent performance and predictable costs, even during peak demand.
• Deterministic: Each Action runs a pre-defined workflow with only the resources and permissions required, producing consistent outcomes.

How Amigo Actions Make Clinical Agents Safer#

To appreciate the difference that Actions make in practice, consider the following scenario with an agent that processes medication refill requests.

Preventing Errors

In the absence of a safety substrate like Actions, the agent might have broad access to the prescribing system and figure out how to complete the task on its own, which introduces room for unpredictable behavior and outcomes.

With Actions, nothing is left to the model's judgment. The refill workflow is precisely defined in advance, including what data to pull, which checks to run, and in what order.

In this example, the Action might include checks to cross-reference the patient's chart and verify that the medication is appropriate for their recorded conditions and allergies before placing the order. If anything is surfaced, the process can be terminated, the care team notified, and the incident logged.

Containing Errors

What if the agent attempts to place the order but the process crashes halfway through? Under a typical setup, this could result in a partial order where the prescription is logged in the patient's chart but never sent to the pharmacy.

With Actions, each operation is atomic, so the medication order completes fully or not at all, and there's no scenario where a partial order goes through.

Recovering From Errors

Once an error is contained, teams can quickly identify which version of the Action was at fault, roll back to a safe version within seconds, and even use the audit trail to cancel or adjust any orders that were placed incorrectly. The Actions architecture creates a clinical-grade safety net, allowing healthcare organizations to deploy patient-facing agents with confidence.

Trusted Execution for Safe, Scalable Agents#

The safest systems in healthcare work on two fronts: minimizing errors and limiting the blast radius when they occur. When it comes to clinical agents, safe execution is non-negotiable and our Actions architecture makes it possible at scale.

We’re building the frontier of safe and intelligent clinical agents - the kind you can trust with lives. Ready to see what clinical-grade AI looks like in practice? Book a call with us today.