Cohere Health 如何利用 Amazon Bedrock AgentCore 将临床政策数字化

事前授权（Prior authorization）是指健康保险计划在承保某些医疗服务或药物前所要求的审批流程。它仍是医疗领域最依赖人工的流程之一，原因并不在于要求审批的医学推理存在问题，而在于支撑这些流程的政策被困在静态、非结构化的格式中，难以实现自动化。这些内容是日常临床运营的核心，每年影响数亿名患者。然而，政策内容会因临床领域、地理区域、业务线和健康保险计划而异，并会随着医学和技术进步不断演变。过去，健康保险计划并没有系统化的方法来管理、分析和优化这些政策。利用标准术语将这些临床政策数字化为结构化、机器可读的数据，可通过支持更一致、可计算的工作流来减少关键运营瓶颈，并帮助健康保险计划在保持适当临床监督的同时，大规模实现事前授权运营现代化。

Cohere Health(R) 是一家为健康保险计划运营提供支持的临床智能公司。该公司使用 Amazon Bedrock AgentCore 构建了 Cohere Policy Studio(TM)。AgentCore 为其健康保险计划客户提供所需的多租户隔离能力，并提供托管式智能体运行时，无需重建基础设施即可加快部署。该应用采用灵活的多租户智能体架构，通过广泛的工作流管理和自动版本跟踪，加速政策数字化。

本文介绍 Cohere Health 如何利用 AgentCore Runtime 的安全 MicroVM 隔离、通过 AgentCore Gateway 实现统一工具访问、AgentCore Memory，以及 Agent Skills 开放标准，在保留透明度、版本控制和人工监督的同时，快速扩展政策数字化能力。

挑战：政策数字化瓶颈

要实现 AI 辅助工作流在事前授权中的价值，需要应对一项基础性挑战：将困在静态文档和 PDF 中的规则转换为结构化、机器可读的数据，使 AI 系统能够更一致地使用这些数据；与此同时，在需要临床判断的场景中，医学专业人员仍应负责临床审核。健康保险计划需要面对复杂的临床政策管理挑战，以支持快速变化的要求。自动化政策数字化能够帮助健康保险计划适应这些变化。

Cohere Health 在为这一工作流构建 AI 解决方案时识别出三项挑战：

• 政府监管要求——根据美国医疗保险和医疗补助服务中心（CMS）的法规，健康保险计划必须在 2027 年 1 月前支持基于 API 的电子事前授权。
• 美国健康保险计划协会（AHIP）——AHIP 承诺要求健康保险计划使电子事前授权申请中 80% 能够获得实时批准。每条业务线都有独特要求，因此更需要快速管理、审计和部署临床政策。
• 技术架构要求——该解决方案需要摄取多种输入格式，并为不同的下游使用方生成每项政策的不同表示形式，而每个使用方都拥有自身的反馈闭环。

AgentCore 通过托管运行时基础设施、会话隔离和统一工具访问来应对这些挑战。

解决方案概览

下图展示了 Cohere Policy Studio 如何将 AgentCore Runtime、Gateway 和 Memory 连接为一个统一的政策数字化智能体系统。

Policy Studio 应用基于 AgentCore 和 Agent Skills 开放标准构建。为了在 Cohere Policy Studio 中扩展政策表示形式，Cohere Health 向一个已在拆解政策的现有 AgentCore Runtime 添加了新技能。该运行时可访问政策技能、通过 AgentCore Gateway 以 Model Context Protocol（MCP）工具形式提供的政策 API，以及用于政策分析师反馈闭环的会话记忆，帮助团队在受治理、人工参与的流程中完善输出结果。

团队完成了三项工作：

• 使用 LangChain 部署了结合 AgentCore Gateway 和 AgentCore Memory 的 AgentCore Runtime，构建完整的智能体系统。
• 配置 AgentCore Gateway 以获取工具和技能。
• 与临床政策专家共同编写技能，并基于 Arize AI 使用 Cohere Health 标准化可观测性流程进行评估。

你可以采用这些相同模式来构建自己的多租户智能体系统。

使用可复用的 Amazon Elastic Container Registry（Amazon ECR）基础镜像部署 AI 智能体

Cohere Health 为多家健康保险计划提供服务，这些客户要求租户之间实现严格的数据隔离。AgentCore Runtime 的安全 microVM 隔离通过为每个会话分配专用计算、内存和文件系统资源来实现这一要求。

当在多个团队之间部署多个 AI 智能体实例时，既要保持一致性，又要允许定制化，这一点非常重要。每个团队都需要自己的智能体配置，但为每次部署重建整个运行时环境会造成不必要的开销和漂移。你可以使用以下基础镜像模式，通过最简 Dockerfile 将新智能体部署到 AgentCore Runtime microVM。

基础镜像与使用方模式

Cohere Health 开发了一种双层部署架构，将稳定的运行时环境与团队特定配置分离：

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

FROM 行会拉取包含 LangChain 智能体框架和通用依赖项的共享基础镜像。COPY 行会添加团队特定的 agent_config.yaml，该文件控制以下选项：

• 内存模式——可选择无状态（NO_MEMORY）或持久化（AGENTCORE）对话历史。
• 存储策略——用于更正工作流的 full_trace，或用于保存干净历史记录的 conversation_only。
• 会话上下文缓存——自动缓存技能定义和文档，避免重复从 Amazon Simple Storage Service（Amazon S3）获取内容。
• 提示词缓存——通过缓存系统提示词和高频使用内容，可帮助降低成本和延迟。
• 灵活的工具配置——可按部署启用或禁用工具。
• 模型配置——使用 Amazon Bedrock 上的基础模型，并可配置 Token 限制、温度及其他推理参数。
• LiteLLM 配置——将 LiteLLM 配置为模型与智能体之间的反向代理。

部署运行时后，下一步是将其连接到工具和技能。

Cohere Health 的智能体可访问多种类型的工具，包括用于获取技能和文档的 AWS Lambda 函数，以及由不同团队维护的内部 API。AgentCore Gateway 将这些工具整合到单一、经过身份验证的端点之后，因此团队可以在无需重新部署智能体的情况下添加新工具。

AgentCore Gateway 架构

Cohere Health 使用 AgentCore Gateway 实现了这一架构，并为共享工具和项目专用工具配置了独立目标。

AgentCore Gateway 会针对每个工具请求调用一个 AWS Lambda 函数。该函数根据网关上下文中传入的工具名称，将请求路由到正确的处理程序。

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

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

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

    # Extract tool name from gateway context
    tool_name = context.client_context.custom.get('bedrockAgentCoreToolName', '')

    # Strip gateway prefix (gateway adds {target}__ to tool names)
    if '__' in tool_name:
        tool_name = tool_name.split('__', 1)[1]

    # Route to appropriate handler
    if tool_name not in TOOL_HANDLERS:
        return {
            "statusCode": 404,
            "body": json.dumps({"error": f"Tool {tool_name} not found"})
        }

    try:
        result = TOOL_HANDLERS[tool_name](event)
        return {
            "statusCode": 200,
            "body": json.dumps(result)
        }
    except Exception as e:
        return {
            "statusCode": 500,
            "body": json.dumps({"error": str(e)})
        }

每个工具处理程序都会从特定来源获取数据。以下示例从 Amazon S3 检索技能定义。

# tools/fetch_skill.py
import boto3
import os

def handler(event: dict) -> dict:
    """Fetch skill definition from S3"""

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

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

    s3 = boto3.client('s3')

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

        return {"content": content}
    except Exception as e:
        return {"error": f"Failed to fetch skill: {str(e)}"}

智能体配置

智能体配置定义了智能体可访问哪些网关目标，以及其身份验证方式。

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

在运行时和工具就绪后，Cohere Health 开始构建领域专业知识层。

技能开发与评估

AI 智能体需要领域专用知识，才能高效执行专业任务。通用提示词会产生不一致的结果，需要大量 Token 使用，并且缺乏领域专家所具备的细致理解。传统上，每个新用例都需要从头重建智能体基础设施，从而对部署速度造成瓶颈。模块化技能框架通过将领域专业知识与基础设施解耦来解决这一问题。对 Cohere Health 而言，这意味着临床政策专家能够直接编写和完善新技能，有助于确保系统以始终基于专家审核和治理的方式支持政策工作流。

模块化技能框架

团队可通过模块化、版本化的技能定义部署新能力，而无需重建智能体。

开发工作流

Cohere Health 遵循结构化工作流，在每项技能进入生产环境之前进行开发和验证。

评估流程

评估技能需要机器学习工程与数据科学团队协作。该流程从参考数据集开始，这些数据集包含每项技能的真实基准输出。团队定义成功指标（准确性、完整性和一致性），并针对这些测试用例运行评估套件。当某项技能失败时，团队会分析失败模式，迭代技能定义后重新测试。

当技能通过评估套件后，数据科学团队将根据验收标准审核结果，并批准该技能部署到生产环境。

部署后，Arize AI 会在生产环境中跟踪有效性指标。临床政策分析师会标注样本输出，以捕捉自动化指标未能发现的错误。团队持续监测技能随时间推移发生的性能退化，并使用这些数据点确定优化工作的优先级。

技能版本控制与部署

技能通过分层版本控制方案和分阶段部署流水线进入生产环境。

双层版本控制

技能采用双层版本控制：用于能力跟踪的语义化版本控制，以及用于部署历史的 Amazon S3 对象版本控制。第一层在 SKILL.md 中跟踪能力变更，每个版本均在 git 中打上标签（例如 skill/policy_ingestion/v1.2.3）。Amazon S3 对象版本控制构成第二层，为每次上传维护不可变历史记录，并提供回滚能力以及独立的非生产环境和生产环境存储桶。

部署流程

1. 开发人员提交代码，并向 develop 分支发起 PR。
2. 合并后，持续集成与持续交付（CI/CD）打包包含元数据的 skill.tar.gz。
3. 流水线上传至 Amazon S3 非生产环境存储桶，并更新清单。
4. 在非生产环境中进行评估。
5. 向 main 分支发起 PR。
6. 通过渐进式发布和监控部署到生产环境。

结果与影响

通过这一实施，Cohere Health 实现了可衡量的改进。

Prior authorization is the approval process health plans require before covering certain medical services or medications. It remains one of the most manual processes in healthcare, not because the medical reasoning for requiring approval is flawed, but because the policies that govern it are trapped in static, unstructured formats that resist automation. This content is at the core of day-to-day clinical operations impacting hundreds of millions of patients each year. However, the policy content varies by clinical area, geography, line of business, and health plan, and evolves as medicine and technology advances. Historically, health plans did not have a systematic way to manage, analyze, and optimize them. Digitizing these clinical policies into structured, machine-readable data using standard terminologies reduce a critical operational bottleneck by supporting more consistent, computable workflows and helping health plans modernize prior authorization operations at scale while maintaining appropriate clinical oversight.

Cohere Health(R), a clinical intelligence company that powers health plan operations, built Cohere Policy Studio(TM) using Amazon Bedrock AgentCore, which provides the multi-tenant isolation required for their health plan customers and a managed agent runtime that accelerates deployment without rebuilding infrastructure. The application uses a flexible, multi-tenant agentic architecture to accelerate policy digitization with extensive workflow management and automatic version tracking.

In this post, you learn how Cohere Health built a multi-tenant agentic architecture on AgentCore using AgentCore Runtime’s secure MicroVM isolation, unified tool access through AgentCore Gateway, AgentCore Memory, and the Agent Skills open standard to rapidly scale policy digitization capabilities, while preserving transparency, version control, and human oversight.

Challenge: The policy digitization bottleneck

Realizing the value of AI-assisted workflows in prior authorization depends on a foundational challenge: transforming the rules trapped in static documents and PDFs into structured, machine-readable data that AI systems can use more consistently, while medical professional remain responsible for clinical review where clinical judgment is required. Health plans face a complex challenge of managing clinical policies to support rapidly changing requirements. Automating policy digitization helps health plans adapt to these changes.

Cohere Health identified three challenges in building an AI solution for this workflow:

• Government regulations – Per Centers for Medicare & Medicaid Services (CMS) regulations, health plans are required to support API-based electronic prior authorization by January 2027.
• America’s Health Insurance Plans (AHIP) – The AHIP commitments require health plans to achieve 80 percent real-time approvals for electronic prior authorization submissions. Each line of business has unique requirements, increasing the need to quickly manage, audit, and deploy clinical policies.
• Technical architecture demands – The solution needed to ingest multiple input formats and produce different representations of each policy for different downstream consumers, each with its own feedback loop.

AgentCore addresses these challenges with managed runtime infrastructure, session isolation, and unified tool access.

Solution overview

The following diagram shows how Cohere Policy Studio connects AgentCore Runtime, Gateway, and Memory into a unified agentic system for policy digitization.

The Policy Studio application is built on AgentCore using the Agent Skills open standard. To scale out representations in Cohere Policy Studio, Cohere Health added new skills to an existing AgentCore Runtime that was already decomposing policies. This runtime had access to the policy skills, policy APIs as Model Context Protocol (MCP) tools through AgentCore Gateway, and session memory for policy analysts’ feedback loops, helping teams refine outputs within a governed, human-in-the-loop process.

The team completed three tasks:

• Deployed AgentCore Runtime with AgentCore Gateway and AgentCore Memory for a full agentic system using LangChain.
• Configured AgentCore Gateway to fetch tools and skills.
• Wrote skills with clinical policy experts and evaluated them using Cohere Health’s standardized observability process based on Arize AI.

You can apply these same patterns to build your own multi-tenant agentic system.

Deploying AI agents with reusable Amazon Elastic Container Registry (Amazon ECR) base images

Cohere Health serves multiple health plans that require strict data isolation between tenants. AgentCore Runtime’s secure microVM isolation enforces this with dedicated compute, memory, and filesystem resources per session.

When deploying multiple AI agent instances across teams, maintaining consistency while allowing customization is important. Each team needs its own agent configuration, but rebuilding the entire runtime environment for every deployment creates unnecessary overhead and drift. You can use the following base image pattern to deploy new agents to AgentCore Runtime microVMs with a minimal Dockerfile.

Base image and consumer pattern

Cohere Health developed a two-tier deployment architecture that separates the stable runtime environment 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 image containing the LangChain agent framework and common dependencies. The COPY line adds the team-specific agent_config.yaml, which controls the following options:

• Memory modes – Choose between stateless (NO_MEMORY) or persistent (AGENTCORE) conversation history.
• Storage strategies – full_trace for correction workflows or conversation_only for clean history.
• Session context caching – Automatically caches skill definitions and documents to avoid redundant Amazon Simple Storage Service (Amazon S3) fetches.
• Prompt caching – Can help reduce costs and latency by caching system prompts and frequently used content.
• Flexible tool configuration – Enable/disable tools per deployment.
• Model configuration – Base model on Amazon Bedrock with configurable token limits, temperature, and other inference parameters.
• LiteLLM configuration – Configure LiteLLM as the reverse proxy between the model and the agent.

With the runtime deployed, the next step was connecting it to tools and skills.

Cohere Health’s agents access multiple tool types, including AWS Lambda functions for fetching skills and documents, and internal APIs, maintained across different teams. AgentCore Gateway consolidates these behind a single authenticated endpoint, so teams add new tools without redeploying the agent.

AgentCore Gateway architecture

Cohere Health implemented this using AgentCore Gateway with separate targets for shared tools and project-specific tools.

AgentCore Gateway invokes an AWS Lambda function for each tool request. The function routes to the correct handler based on the tool name passed in the gateway context.

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

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

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

    # Extract tool name from gateway context
    tool_name = context.client_context.custom.get('bedrockAgentCoreToolName', '')

    # Strip gateway prefix (gateway adds {target}__ to tool names)
    if '__' in tool_name:
        tool_name = tool_name.split('__', 1)[1]

    # Route to appropriate handler
    if tool_name not in TOOL_HANDLERS:
        return {
            "statusCode": 404,
            "body": json.dumps({"error": f"Tool {tool_name} not found"})
        }

    try:
        result = TOOL_HANDLERS[tool_name](event)
        return {
            "statusCode": 200,
            "body": json.dumps(result)
        }
    except Exception as e:
        return {
            "statusCode": 500,
            "body": json.dumps({"error": str(e)})
        }

Each tool handler fetches data from a specific source. The following example retrieves a skill definition from Amazon S3.

# tools/fetch_skill.py
import boto3
import os

def handler(event: dict) -> dict:
    """Fetch skill definition from S3"""

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

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

    s3 = boto3.client('s3')

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

        return {"content": content}
    except Exception as e:
        return {"error": f"Failed to fetch skill: {str(e)}"}

Agent configuration

The agent configuration defines which gateway targets the agent can access and how it authenticates.

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

With the runtime and tools in place, Cohere Health turned to building the domain expertise layer.

Skills development and evaluation

AI agents need domain-specific knowledge to perform specialized tasks effectively. Generic prompts produce inconsistent results, require extensive token usage, and lack the nuanced understanding that domain experts bring. Each new use case traditionally required rebuilding agent infrastructure from scratch, creating bottlenecks in deployment velocity. A modular skills framework addresses this by decoupling domain expertise from infrastructure. For Cohere Health, this means clinical policy experts can author and refine new skills directly, helping ensure the system supports policy workflows in ways that remain grounded in expert review and governance.

Modular skills framework

Teams deploy new capabilities through modular, versioned skill definitions without rebuilding the agent.

Development workflow

Cohere Health follows a structured workflow to develop and validate each skill before it reaches production.

Evaluation process

Evaluating skills requires collaboration between machine learning engineering and data science. The process starts with reference datasets that contain ground truth outputs for each skill. The team defines success metrics (accuracy, completeness, and consistency) and runs an evaluation suite against these test cases. When a skill fails, the team analyzes the failure mode and iterates on the skill definition before retesting.

After a skill passes the evaluation suite, data science reviews the results against acceptance criteria and approves the skill for production deployment.

After deployment, Arize AI tracks effectiveness metrics in production. Clinical policy analysts annotate sample outputs to catch errors the automated metrics miss. The team monitors for skill degradation over time and uses these data points to prioritize optimization work.

Skill versioning and deployment

Skills move to production through a layered versioning scheme and a staged deployment pipeline.

Dual-layer versioning

Skills use dual-layer versioning: semantic versioning for capability tracking and Amazon S3 object versioning for deployment history. The first layer tracks capability changes in SKILL.md, with each version tagged in git (for example, skill/policy_ingestion/v1.2.3). Amazon S3 object versioning provides the second layer, maintaining immutable history for every upload with rollback capability and separate non-prod/prod buckets.

Deployment flow

1. Developer commits and opens a PR to develop.
2. Continuous integration and continuous delivery (CI/CD) packages skill.tar.gz with metadata on merge.
3. The pipeline uploads to the Amazon S3 non-prod bucket and updates the manifest.
4. Evaluate in non-prod environment.
5. Open PR to main.
6. Deploy to prod with gradual rollout and monitoring.

Results and impact

Through this implementation, Cohere Health achieved measurable improvements across policy digitization speed, deployment velocity, and coverage.

Policy digitization efficiency: Overall time spent on policy digitization reduced by 30 percent, from 2 hours 15 minutes to 1 hour 35 minutes per policy. Cohere Health has digitized thousands of policies to date using manual and semi-automated workflows. The agent-based framework targets further time reduction per policy as it scales across the existing policy library.

Deployment velocity: Full agent deployments in the product decreased from 3–4 months to 2–6 weeks. The reusable ECR base image pattern lets teams stand up a new agent with a minimal Dockerfile, and the modular skills framework means new capabilities ship without rebuilding the agent runtime. The system abstracts DevOps concerns, so traditional machine learning (ML) and data science engineers can deploy agents without extensive coding experience. The policy digitization product runs a single-agent, multi-skill architecture with one agent, a primary skill with a sub-skill, and three reference injections.

Policy coverage: Cohere Policy Studio represents policy content with verbatim text and a standard codified evidence layer, packaged together and available across original policy formats and sources.

“Prior authorization policy review has always demanded an extraordinary level of clinical attention—every word in a policy document can carry downstream consequences for patients. But that attention has historically been split between interpretation and verification: not just understanding what a policy means clinically, but confirming which version of it governed a given decision, and whether that same version is what the health plan published to providers. Those aren’t administrative questions—they’re questions that bear directly on clinical integrity. Amazon Bedrock AgentCore gave us the architecture to address both simultaneously—AI-powered agentic workflows that assist with navigating the interpretive complexity of clinical language, with built-in memory and version tracking that make provenance a first-class concern rather than an afterthought. Structured, versioned policy outputs make the clinical basis of a decision traceable and reviewable by design, and AgentCore’s secure, multi-tenant runtime means we can deliver that capability across every health plan we serve without compromising isolation.”

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

Apply these patterns to achieve similar results: reusable base images for consistent deployments, unified tool access through a single gateway, and modular skills that scale without rebuilding infrastructure.

Future: Connecting policies through a knowledge graph

Building on Cohere Policy Studio’s success with AgentCore, the next evolution introduces an intelligent knowledge graph which is already underway. Working with the AWS Generative AI Innovation Center, Cohere Health prototyped the foundational semantic layer mapping clinical policies to standardized ontologies (UMLS, SNOMED) to support greater interoperability using standardized healthcare terms. Using Amazon Neptune, this grounds policy concepts in a structure that AI can traverse and trace. That graph connects clinical policies with decisioning products across expanded indications.

Enhanced architecture

The knowledge graph layer sits between the policy representation engine and downstream decisioning systems, creating a semantic network that:

• Maps relationships between policies, clinical guidelines, medical codes (ICD-10, CPT, HCPCS), drug formularies, and prior authorization criteria across therapeutic areas.
• Scales indication coverage by identifying patterns and similarities across clinical domains, so that new policy types deploy rapidly without manual configuration.
• Connects policy fragments to multiple decisioning contexts, so that a single policy update propagates correctly across affected authorization workflows.

Key capabilities

As new policies are digitized through AgentCore, the knowledge graph is designed to help identify relevant connections, flag potential conflicts, and suggest reusable patterns to support reviewer and policy team workflows. The graph learns from policy structures across clinical areas, suggesting templates and accelerating time-to-deployment for new indication types from days to hours. Decisioning engines query the knowledge graph using natural language or Fast Healthcare Interoperability Resources (FHIR) resources to retrieve potentially relevant policy fragments with full provenance and version history. The graph also maintains bidirectional links between CMS requirements, AHIP commitments, and internal policy representations, supporting regulatory alignment at scale.

These capabilities deliver comprehensive indication coverage without proportional engineering effort, real-time policy updates across connected decisioning products, automated conflict detection to help prevent inconsistent authorization outcomes, and sub-second policy retrieval for authorization requests.

This knowledge graph foundation supports Cohere Health’s ability to help health plans achieve 80 percent of electronic prior authorization approvals in real time. The graph maintains the security, multi-tenancy, and audit capabilities established in the current AgentCore architecture.

Conclusion

In this post, you learned how Cohere Health used AgentCore and three architectural decisions to reduce AI agent deployment from months to weeks. Three patterns (reusable ECR base images, unified tool access through AgentCore Gateway, and modular skills development) helped Cohere Health support more scalable policy digitization workflows across formats while reducing digitization time by 30%.

The ECR base image pattern alleviates redundant infrastructure work, so teams can deploy new agents with a minimal Dockerfile. Cohere Health can scale the AI system without rebuilding the runtime. The AgentCore Gateway architecture provides a single authenticated endpoint for the tools, whether they’re utilities based on AWS Lambda or OpenAPI services. The skills framework, built on the Agent Skills open standard, separates domain expertise from agent mechanics, supporting rapid iteration with continuous evaluation through Arize AI and clinical policy analysts.

The future of healthcare AI depends on systems that can adapt quickly to changing requirements while maintaining reliability and security. With AgentCore and these architectural patterns, you can build that system today.

To get started with these patterns in your own environment, explore the following resources:

Learn about Cohere Health’s other AgentCore deployment of a medical necessity review agentic assistant in this re:Invent session.

If you’re a startup building production-ready AI agents, AWS Activate provides the credits, technical guidance, and architecture support to help you move from prototype to production. Get started today.

If you have feedback or questions about this post, leave a comment in the comments section.

---

About the authors

Oleksiy Kononenko

Oleksiy is a Solutions Architect on the State and Local Government team at AWS, where he partners with government agencies to use cloud technologies to improve citizen services. With his previous Healthcare and Life Sciences Startups experience at AWS, he brings a unique builder’s perspective to architecting solutions that solve real-world problems. When not working with customers, you’ll find him exploring new tech or mountain biking.

Kenji Fujita

Kenji is a Staff AI Platform Engineer at Cohere Health, where he has worked for the past six years. Throughout his tenure, he has developed many of the capabilities across the various platforms that the new agent framework is scaling out to support. You can find Kenji suffering while watching the Mets and running in his free time.

Vikas Mehta

Vikas is a Machine Learning Engineer at Cohere Health, where he started as a co-op during his MSCS at UMass Amherst. He is a contributor to the framework outlined in this post. When he’s not working, Vikas enjoys swimming, board games with friends, and exploring parks and restaurants around the city.

Anna Wang

Anna is a Software Engineer at Cohere Health, where she started as an intern during her undergraduate studies at Tufts University. She is a contributor to the framework outlined in this post. Outside of work, Anna’s current obsessions are sourdough and distance running.

Ebad Ahmadzadeh

Ebad is a Principal Machine Learning Engineer at Cohere Health, where he has worked for the past four years. He led research and implementation for many of the ML products at the company. Ebad enjoys learning about music theory, spends time with his family, and goes on dog walks.

Adwait Patil

Adwait is a Machine Learning Engineer at Cohere Health, where he started as a co-op during his MSDS at Northeastern’s Khoury College of Computer Sciences. He has worked extensively on Cohere Policy Studio. Adwait can usually be found hiking or playing badminton or basketball, often using it as the perfect excuse to explore new food spots.