待翻译：How Cohere Health digitizes clinical policies using Amazon Bedrock AgentCore

AI 服务暂时不可用，以下为来源正文，待恢复后补全翻译。

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. Unified tool and skill access with AgentCore Gateway 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. Tool Lambda function structure 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)}) } Tool implementation 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 Developer commits and opens a PR to develop. Continuous integration and continuous delivery (CI/CD) packages skill.tar.gz with metadata on merge. The pipeline uploads to the Amazon S3 non-prod bucket and updates the manifest. Evaluate [truncated for AI cost control]