How Cohere Well being digitizes medical insurance policies utilizing Amazon Bedrock AgentCore

August 8, 2026

3

Prior authorization is the approval course of well being plans require earlier than overlaying sure medical providers or medicines. It stays some of the handbook processes in healthcare, not as a result of the medical reasoning for requiring approval is flawed, however as a result of the insurance policies that govern it are trapped in static, unstructured codecs that resist automation. This content material is on the core of day-to-day medical operations impacting tons of of tens of millions of sufferers annually. Nonetheless, the coverage content material varies by medical space, geography, line of enterprise, and well being plan, and evolves as drugs and know-how advances. Traditionally, well being plans didn’t have a scientific solution to handle, analyze, and optimize them. Digitizing these medical insurance policies into structured, machine-readable knowledge utilizing customary terminologies scale back a essential operational bottleneck by supporting extra constant, computable workflows and serving to well being plans modernize prior authorization operations at scale whereas sustaining acceptable medical oversight.

Cohere Well being^(R), a medical intelligence firm that powers well being plan operations, constructed Cohere Coverage Studio^(TM) utilizing Amazon Bedrock AgentCore, which offers the multi-tenant isolation required for his or her well being plan clients and a managed agent runtime that accelerates deployment with out rebuilding infrastructure. The appliance makes use of a versatile, multi-tenant agentic structure to speed up coverage digitization with intensive workflow administration and computerized model monitoring.

On this submit, you find out how Cohere Well being constructed a multi-tenant agentic structure on AgentCore utilizing AgentCore Runtime’s safe MicroVM isolation, unified software entry via AgentCore Gateway, AgentCore Reminiscence, and the Agent Expertise open customary to quickly scale coverage digitization capabilities, whereas preserving transparency, model management, and human oversight.

Problem: The coverage digitization bottleneck

Realizing the worth of AI-assisted workflows in prior authorization is determined by a foundational problem: remodeling the foundations trapped in static paperwork and PDFs into structured, machine-readable knowledge that AI methods can use extra constantly, whereas medical skilled stay chargeable for medical overview the place medical judgment is required. Well being plans face a posh problem of managing medical insurance policies to assist quickly altering necessities. Automating coverage digitization helps well being plans adapt to those adjustments.

Cohere Well being recognized three challenges in constructing an AI answer for this workflow:

Authorities rules – Per Facilities for Medicare & Medicaid Companies (CMS) rules, well being plans are required to assist API-based digital prior authorization by January 2027.
America’s Well being Insurance coverage Plans (AHIP) – The AHIP commitments require well being plans to attain 80 % real-time approvals for digital prior authorization submissions. Every line of enterprise has distinctive necessities, growing the necessity to shortly handle, audit, and deploy medical insurance policies.
Technical structure calls for – The answer wanted to ingest a number of enter codecs and produce totally different representations of every coverage for various downstream customers, every with its personal suggestions loop.

AgentCore addresses these challenges with managed runtime infrastructure, session isolation, and unified software entry.

Answer overview

The next diagram reveals how Cohere Coverage Studio connects AgentCore Runtime, Gateway, and Reminiscence right into a unified agentic system for coverage digitization.

The Coverage Studio utility is constructed on AgentCore utilizing the Agent Expertise open customary. To scale out representations in Cohere Coverage Studio, Cohere Well being added new abilities to an present AgentCore Runtime that was already decomposing insurance policies. This runtime had entry to the coverage abilities, coverage APIs as Mannequin Context Protocol (MCP) instruments via AgentCore Gateway, and session reminiscence for coverage analysts’ suggestions loops, serving to groups refine outputs inside a ruled, human-in-the-loop course of.

The crew accomplished three duties:

Deployed AgentCore Runtime with AgentCore Gateway and AgentCore Reminiscence for a full agentic system utilizing LangChain.
Configured AgentCore Gateway to fetch instruments and abilities.
Wrote abilities with medical coverage specialists and evaluated them utilizing Cohere Well being’s standardized observability course of primarily based on Arize AI.

You possibly can apply these similar patterns to construct your individual multi-tenant agentic system.

Deploying AI brokers with reusable Amazon Elastic Container Registry (Amazon ECR) base pictures

Cohere Well being serves a number of well being plans that require strict knowledge isolation between tenants. AgentCore Runtime’s safe microVM isolation enforces this with devoted compute, reminiscence, and filesystem sources per session.

When deploying a number of AI agent situations throughout groups, sustaining consistency whereas permitting customization is essential. Every crew wants its personal agent configuration, however rebuilding the complete runtime surroundings for each deployment creates pointless overhead and drift. You should utilize the next base picture sample to deploy new brokers to AgentCore Runtime microVMs with a minimal Dockerfile.

Base picture and client sample

Cohere Well being developed a two-tier deployment structure that separates the secure runtime surroundings from team-specific configurations:

FROM {account_id}.dkr.ecr.{aws_region}.amazonaws.com/cohere-agent:v1
COPY agent_config.yaml /app/src/agent_config.yaml

The FROM line pulls the shared base picture containing the LangChain agent framework and customary dependencies. The COPY line provides the team-specific agent_config.yaml, which controls the next choices:

Reminiscence modes – Select between stateless (NO_MEMORY) or persistent (AGENTCORE) dialog historical past.
Storage methods – full_trace for correction workflows or conversation_only for clear historical past.
Session context caching – Mechanically caches ability definitions and paperwork to keep away from redundant Amazon Easy Storage Service (Amazon S3) fetches.
Immediate caching – Can assist scale back prices and latency by caching system prompts and regularly used content material.
Versatile software configuration – Allow/disable instruments per deployment.
Mannequin configuration – Base mannequin on Amazon Bedrock with configurable token limits, temperature, and different inference parameters.
LiteLLM configuration – Configure LiteLLM because the reverse proxy between the mannequin and the agent.

With the runtime deployed, the following step was connecting it to instruments and abilities.

Unified software and ability entry with AgentCore Gateway

Cohere Well being’s brokers entry a number of software varieties, together with AWS Lambda features for fetching abilities and paperwork, and inner APIs, maintained throughout totally different groups. AgentCore Gateway consolidates these behind a single authenticated endpoint, so groups add new instruments with out redeploying the agent.

AgentCore Gateway structure

Cohere Well being carried out this utilizing AgentCore Gateway with separate targets for shared instruments and project-specific instruments.

Device Lambda perform construction

AgentCore Gateway invokes an AWS Lambda perform for every software request. The perform routes to the right handler primarily based on the software identify handed within the gateway context.

# jobs/generic-tools-lambda/app.py
import json
from instruments.fetch_skill import handler as fetch_skill_handler

# Routing dictionary for software discovery
TOOL_HANDLERS = {
    "fetch_skill": fetch_skill_handler
}

def lambda_handler(occasion, context):
    """Gateway-compliant Lambda handler with MCP routing"""

    # Extract software identify from gateway context
    tool_name = context.client_context.customized.get('bedrockAgentCoreToolName', '')

    # Strip gateway prefix (gateway provides {goal}__ to software names)
    if '__' in tool_name:
        tool_name = tool_name.cut up('__', 1)[1]

    # Path to acceptable handler
    if tool_name not in TOOL_HANDLERS:
        return {
            "statusCode": 404,
            "physique": json.dumps({"error": f"Device {tool_name} not discovered"})
        }

    strive:
        outcome = TOOL_HANDLERS[tool_name](occasion)
        return {
            "statusCode": 200,
            "physique": json.dumps(outcome)
        }
    besides Exception as e:
        return {
            "statusCode": 500,
            "physique": json.dumps({"error": str(e)})
        }

Device implementation

Every software handler fetches knowledge from a selected supply. The next instance retrieves a ability definition from Amazon S3.

# instruments/fetch_skill.py
import boto3
import os

def handler(occasion: dict) -> dict:
    """Fetch ability definition from S3"""

    skill_id = occasion.get('skill_id')
    if not skill_id:
        return {"error": "skill_id required"}

    # Use surroundings variables for configuration
    bucket = os.environ.get('SKILLS_BUCKET')
    prefix = os.environ.get('SKILLS_PREFIX')

    s3 = boto3.shopper('s3')

    strive:
        response = s3.get_object(
            Bucket=bucket,
            Key=f"{prefix}/{skill_id}.yaml"
        )
        content material = response['Body'].learn().decode('utf-8')

        return {"content material": content material}
    besides Exception as e:
        return {"error": f"Didn't fetch ability: {str(e)}"}

Agent configuration

The agent configuration defines which gateway targets the agent can entry and the way it authenticates.

# agent_config.yaml
mcp:
  gateway_url: {gateway_url}
  allowed_targets:
    - generic-tools    # AIP-maintained instruments
    - digitization-tools  # Mission-specific instruments
  auth_mode: "bearer_token"

With the runtime and instruments in place, Cohere Well being turned to constructing the area experience layer.

Expertise growth and analysis

AI brokers want domain-specific information to carry out specialised duties successfully. Generic prompts produce inconsistent outcomes, require intensive token utilization, and lack the nuanced understanding that area specialists deliver. Every new use case historically required rebuilding agent infrastructure from scratch, creating bottlenecks in deployment velocity. A modular abilities framework addresses this by decoupling area experience from infrastructure. For Cohere Well being, this implies medical coverage specialists can writer and refine new abilities straight, serving to make sure the system helps coverage workflows in ways in which stay grounded in skilled overview and governance.

Modular abilities framework

Groups deploy new capabilities via modular, versioned ability definitions with out rebuilding the agent.

Growth workflow

Cohere Well being follows a structured workflow to develop and validate every ability earlier than it reaches manufacturing.

Analysis course of

Evaluating abilities requires collaboration between machine studying engineering and knowledge science. The method begins with reference datasets that comprise floor fact outputs for every ability. The crew defines success metrics (accuracy, completeness, and consistency) and runs an analysis suite in opposition to these take a look at circumstances. When a ability fails, the crew analyzes the failure mode and iterates on the ability definition earlier than retesting.

After a ability passes the analysis suite, knowledge science evaluations the outcomes in opposition to acceptance standards and approves the ability for manufacturing deployment.

After deployment, Arize AI tracks effectiveness metrics in manufacturing. Medical coverage analysts annotate pattern outputs to catch errors the automated metrics miss. The crew displays for ability degradation over time and makes use of these knowledge factors to prioritize optimization work.

Talent versioning and deployment

Expertise transfer to manufacturing via a layered versioning scheme and a staged deployment pipeline.

Twin-layer versioning

Expertise use dual-layer versioning: semantic versioning for functionality monitoring and Amazon S3 object versioning for deployment historical past. The primary layer tracks functionality adjustments in SKILL.md, with every model tagged in git (for instance, ability/policy_ingestion/v1.2.3). Amazon S3 object versioning offers the second layer, sustaining immutable historical past for each add with rollback functionality and separate non-prod/prod buckets.

Deployment stream

Developer commits and opens a PR to develop.
Steady integration and steady supply (CI/CD) packages ability.tar.gz with metadata on merge.
The pipeline uploads to the Amazon S3 non-prod bucket and updates the manifest.
Consider in non-prod surroundings.
Open PR to predominant.
Deploy to prod with gradual rollout and monitoring.

Outcomes and influence

By means of this implementation, Cohere Well being achieved measurable enhancements throughout coverage digitization pace, deployment velocity, and protection.

Coverage digitization effectivity: General time spent on coverage digitization diminished by 30 %, from 2 hours quarter-hour to 1 hour 35 minutes per coverage. Cohere Well being has digitized hundreds of insurance policies thus far utilizing handbook and semi-automated workflows. The agent-based framework targets additional time discount per coverage because it scales throughout the prevailing coverage library.

Deployment velocity: Full agent deployments within the product decreased from 3–4 months to 2–6 weeks. The reusable ECR base picture sample lets groups get up a brand new agent with a minimal Dockerfile, and the modular abilities framework means new capabilities ship with out rebuilding the agent runtime. The system abstracts DevOps issues, so conventional machine studying (ML) and knowledge science engineers can deploy brokers with out intensive coding expertise. The coverage digitization product runs a single-agent, multi-skill structure with one agent, a major ability with a sub-skill, and three reference injections.

Coverage protection: Cohere Coverage Studio represents coverage content material with verbatim textual content and an ordinary codified proof layer, packaged collectively and out there throughout unique coverage codecs and sources.

“Prior authorization coverage overview has at all times demanded a rare degree of medical consideration—each phrase in a coverage doc can carry downstream penalties for sufferers. However that spotlight has traditionally been cut up between interpretation and verification: not simply understanding what a coverage means clinically, however confirming which model of it ruled a given choice, and whether or not that very same model is what the well being plan revealed to suppliers. These aren’t administrative questions—they’re questions that bear straight on medical integrity. Amazon Bedrock AgentCore gave us the structure to deal with each concurrently—AI-powered agentic workflows that help with navigating the interpretive complexity of medical language, with built-in reminiscence and model monitoring that make provenance a first-class concern relatively than an afterthought. Structured, versioned coverage outputs make the medical foundation of a call traceable and reviewable by design, and AgentCore’s safe, multi-tenant runtime means we are able to ship that functionality throughout each well being plan we serve with out compromising isolation.”

— Brian Covino, M.D., FAAOS, Chief Medical Officer, Cohere Well being

Apply these patterns to attain related outcomes: reusable base pictures for constant deployments, unified software entry via a single gateway, and modular abilities that scale with out rebuilding infrastructure.

Future: Connecting insurance policies via a information graph

Constructing on Cohere Coverage Studio’s success with AgentCore, the following evolution introduces an clever information graph which is already underway. Working with the AWS Generative AI Innovation Heart, Cohere Well being prototyped the foundational semantic layer mapping medical insurance policies to standardized ontologies (UMLS, SNOMED) to assist larger interoperability utilizing standardized healthcare phrases. Utilizing Amazon Neptune, this grounds coverage ideas in a construction that AI can traverse and hint. That graph connects medical insurance policies with decisioning merchandise throughout expanded indications.

Enhanced structure

The information graph layer sits between the coverage illustration engine and downstream decisioning methods, making a semantic community that:

Maps relationships between insurance policies, medical pointers, medical codes (ICD-10, CPT, HCPCS), drug formularies, and prior authorization standards throughout therapeutic areas.
Scales indication protection by figuring out patterns and similarities throughout medical domains, in order that new coverage varieties deploy quickly with out handbook configuration.
Connects coverage fragments to a number of decisioning contexts, so {that a} single coverage replace propagates appropriately throughout affected authorization workflows.

Key capabilities

As new insurance policies are digitized via AgentCore, the information graph is designed to assist determine related connections, flag potential conflicts, and recommend reusable patterns to assist reviewer and coverage crew workflows. The graph learns from coverage constructions throughout medical areas, suggesting templates and accelerating time-to-deployment for brand new indication varieties from days to hours. Decisioning engines question the information graph utilizing pure language or Quick Healthcare Interoperability Sources (FHIR) sources to retrieve doubtlessly related coverage fragments with full provenance and model historical past. The graph additionally maintains bidirectional hyperlinks between CMS necessities, AHIP commitments, and inner coverage representations, supporting regulatory alignment at scale.

These capabilities ship complete indication protection with out proportional engineering effort, real-time coverage updates throughout linked decisioning merchandise, automated battle detection to assist stop inconsistent authorization outcomes, and sub-second coverage retrieval for authorization requests.

This information graph basis helps Cohere Well being’s potential to assist well being plans obtain 80 % of digital prior authorization approvals in actual time. The graph maintains the safety, multi-tenancy, and audit capabilities established within the present AgentCore structure.

Conclusion

On this submit, you realized how Cohere Well being used AgentCore and three architectural selections to scale back AI agent deployment from months to weeks. Three patterns (reusable ECR base pictures, unified software entry via AgentCore Gateway, and modular abilities growth) helped Cohere Well being assist extra scalable coverage digitization workflows throughout codecs whereas lowering digitization time by 30%.

The ECR base picture sample alleviates redundant infrastructure work, so groups can deploy new brokers with a minimal Dockerfile. Cohere Well being can scale the AI system with out rebuilding the runtime. The AgentCore Gateway structure offers a single authenticated endpoint for the instruments, whether or not they’re utilities primarily based on AWS Lambda or OpenAPI providers. The talents framework, constructed on the Agent Expertise open customary, separates area experience from agent mechanics, supporting speedy iteration with steady analysis via Arize AI and medical coverage analysts.

The way forward for healthcare AI is determined by methods that may adapt shortly to altering necessities whereas sustaining reliability and safety. With AgentCore and these architectural patterns, you possibly can construct that system right this moment.

To get began with these patterns in your individual surroundings, discover the next sources:

Study Cohere Well being’s different AgentCore deployment of a medical necessity overview agentic assistant on this re:Invent session.

Cohere Review Resolve product features demonstrated during an AWS re:Invent session

If you happen to’re a startup constructing production-ready AI brokers, AWS Activate offers the credit, technical steering, and structure assist that can assist you transfer from prototype to manufacturing. Get began right this moment.

When you’ve got suggestions or questions on this submit, go away a remark within the feedback part.