Multi-Agent Systems — Coordinating Specialised AI Agents

Single agent with all tools:
  → One agent has 20+ tools for prescriptions, labs, discharge, billing, appointments
  → Prompt becomes complex and the agent loses focus
  → Tool selection errors increase with larger tool sets
  → One failure affects all functionality
  → Difficult to test, audit, or improve one area without affecting others

Multi-agent system:
  PrescriptionAgent   → tools: find_patient, list_prescriptions, get_prescription_detail
  LabResultsAgent     → tools: get_inr, get_blood_results, get_lab_history
  DischargeAgent      → tools: check_discharge_readiness, schedule_followup, get_bed_status
  OrchestratorAgent   → delegates to specialist agents, synthesises results

Benefits:
  → Each agent has a focused, small tool set — better tool selection accuracy
  → Agents can run in parallel for independent tasks
  → Failures are isolated to one agent
  → Each agent can be tested and improved independently
  → Clear audit trail per agent type

// Orchestrator delegates to specialist agents based on the question

public sealed class ClinicalOrchestratorAgent
{
    private readonly PrescriptionReviewAgent _prescriptionAgent;
    private readonly LabResultsAgent         _labAgent;
    private readonly DischargeReadinessAgent _dischargeAgent;
    private readonly IChatCompletionService  _chat;
    private readonly Kernel                  _kernel;

    public async Task<string> HandleAsync(string mrn, string query, CancellationToken ct)
    {
        // Orchestrator decides which agent(s) to invoke
        var routingDecision = await RouteQueryAsync(query, ct);

        return routingDecision switch
        {
            AgentRoute.Prescriptions => await _prescriptionAgent.ReviewAsync(mrn, query, ct),
            AgentRoute.LabResults    => await _labAgent.GetResultsAsync(mrn, query, ct),
            AgentRoute.Discharge     => await _dischargeAgent.AssessAsync(mrn, query, ct),
            AgentRoute.Full          => await RunFullReviewAsync(mrn, query, ct),
            _                        => "I couldn't determine which specialist to consult."
        };
    }

    private async Task<string> RunFullReviewAsync(
        string mrn, string query, CancellationToken ct)
    {
        // Run independent specialist agents in parallel
        var prescriptionTask = _prescriptionAgent.ReviewAsync(mrn, query, ct);
        var labTask          = _labAgent.GetResultsAsync(mrn, query, ct);

        await Task.WhenAll(prescriptionTask, labTask);

        // Pass both specialist outputs to a synthesis step
        return await SynthesiseAsync(
            mrn,
            prescriptionSummary: prescriptionTask.Result,
            labSummary:          labTask.Result,
            ct);
    }

    private async Task<string> SynthesiseAsync(
        string mrn,
        string prescriptionSummary,
        string labSummary,
        CancellationToken ct)
    {
        var synthesisHistory = new ChatHistory("""
            You are a senior clinical pharmacist synthesising specialist reports.
            Combine the prescription review and lab results into a single coherent assessment.
            Highlight any interactions between the lab results and current medications.
            Always state that the prescriber makes the final clinical decision.
            """);

        synthesisHistory.AddUserMessage($"""
            Patient: {mrn}

            Prescription Review:
            {prescriptionSummary}

            Lab Results:
            {labSummary}

            Please synthesise these into a combined clinical assessment.
            """);

        var response = await _chat.GetChatMessageContentAsync(
            synthesisHistory,
            new OpenAIPromptExecutionSettings { Temperature = 0.2 },
            _kernel,
            ct);

        return response.Content ?? string.Empty;
    }

    private async Task<AgentRoute> RouteQueryAsync(string query, CancellationToken ct)
    {
        var routingHistory = new ChatHistory("""
            You classify clinical questions into one of these categories:
            - prescriptions: questions about medications, doses, prescriptions
            - lab_results: questions about INR, blood tests, lab values
            - discharge: questions about discharge readiness, follow-up
            - full: questions requiring both prescription and lab information
            Respond with ONLY the category name.
            """);

        routingHistory.AddUserMessage(query);

        var response = await _chat.GetChatMessageContentAsync(
            routingHistory,
            new OpenAIPromptExecutionSettings { Temperature = 0 },
            _kernel,
            ct);

        return (response.Content?.Trim().ToLowerInvariant()) switch
        {
            "prescriptions" => AgentRoute.Prescriptions,
            "lab_results"   => AgentRoute.LabResults,
            "discharge"     => AgentRoute.Discharge,
            "full"          => AgentRoute.Full,
            _               => AgentRoute.Prescriptions
        };
    }
}

public enum AgentRoute { Prescriptions, LabResults, Discharge, Full }

// Agents communicate via structured messages — not direct method calls
// This enables async handoffs and audit trails

public sealed record AgentMessage(
    string   FromAgent,
    string   ToAgent,
    string   PatientMrn,
    string   MessageType,
    string   Content,
    DateTime CreatedAt);

public sealed record AgentResponse(
    string   FromAgent,
    string   PatientMrn,
    string   MessageType,
    string   Content,
    bool     RequiresHumanReview,
    DateTime RespondedAt);

// Message bus for agent communication:
public interface IAgentMessageBus
{
    Task PublishAsync(AgentMessage message, CancellationToken ct);
    Task<AgentResponse> RequestResponseAsync(AgentMessage message, CancellationToken ct);
}

// Prescription agent receives and responds to messages:
public sealed class PrescriptionReviewAgent
{
    private readonly Kernel                _kernel;
    private readonly IChatCompletionService _chat;

    public async Task<AgentResponse> HandleMessageAsync(
        AgentMessage message, CancellationToken ct)
    {
        var review = await ReviewAsync(message.PatientMrn, message.Content, ct);

        // Flag for human review if the response contains safety concerns
        var requiresReview = review.Contains("out of range", StringComparison.OrdinalIgnoreCase) ||
                             review.Contains("urgent",       StringComparison.OrdinalIgnoreCase) ||
                             review.Contains("not found",    StringComparison.OrdinalIgnoreCase);

        return new AgentResponse(
            FromAgent:           "PrescriptionAgent",
            PatientMrn:         message.PatientMrn,
            MessageType:        "prescription_review",
            Content:            review,
            RequiresHumanReview: requiresReview,
            RespondedAt:        DateTime.UtcNow);
    }

    public async Task<string> ReviewAsync(string mrn, string query, CancellationToken ct)
    {
        var history = new ChatHistory(PrescriptionSystemPrompt);
        history.AddUserMessage(query);

        var settings = new OpenAIPromptExecutionSettings
        {
            ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions,
            Temperature      = 0.1
        };

        var response = await _chat.GetChatMessageContentAsync(
            history, settings, _kernel, ct);

        return response.Content ?? string.Empty;
    }

    private const string PrescriptionSystemPrompt = """
        You are a specialist prescription review agent.
        You only answer questions about prescriptions, medication doses, and frequencies.
        You do not assess lab results — if asked about lab results, say
        "Please direct lab questions to the lab results agent."
        """;
}

// Agents hand off to humans when clinical decisions require authorisation

public sealed class HighRiskPrescriptionAgent
{
    private readonly IChatCompletionService _chat;
    private readonly Kernel                 _kernel;
    private readonly IHumanReviewQueue      _reviewQueue;

    public async Task<AgentHandoffResult> ReviewHighRiskAsync(
        string mrn, string prescriptionQuery, CancellationToken ct)
    {
        // Agent performs its analysis
        var history = new ChatHistory(HighRiskSystemPrompt);
        history.AddUserMessage(prescriptionQuery);

        var settings = new OpenAIPromptExecutionSettings
        {
            ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions,
            Temperature      = 0.1
        };

        var analysis = await _chat.GetChatMessageContentAsync(
            history, settings, _kernel, ct);

        var content = analysis.Content ?? string.Empty;

        // If analysis flags risk, hand off to human pharmacist
        if (ContentRequiresHumanReview(content))
        {
            var reviewId = await _reviewQueue.EnqueueAsync(
                new HumanReviewRequest(
                    PatientMrn:    mrn,
                    AgentAnalysis: content,
                    Query:         prescriptionQuery,
                    Priority:      DetermineReviewPriority(content),
                    RequestedAt:   DateTime.UtcNow),
                ct);

            return AgentHandoffResult.RequiresHumanReview(
                reviewId,
                "This prescription requires review by a senior pharmacist. " +
                "A review request has been raised. You will be notified when complete.");
        }

        return AgentHandoffResult.Completed(content);
    }

    private static bool ContentRequiresHumanReview(string content) =>
        content.Contains("high risk",       StringComparison.OrdinalIgnoreCase) ||
        content.Contains("contraindicated", StringComparison.OrdinalIgnoreCase) ||
        content.Contains("allergy",         StringComparison.OrdinalIgnoreCase) ||
        content.Contains("urgent review",   StringComparison.OrdinalIgnoreCase);

    private static ReviewPriority DetermineReviewPriority(string content) =>
        content.Contains("urgent", StringComparison.OrdinalIgnoreCase)
            ? ReviewPriority.High
            : ReviewPriority.Normal;

    private const string HighRiskSystemPrompt = """
        You are a specialist high-risk medication review agent.
        You review prescriptions for high-risk medications: anticoagulants, immunosuppressants,
        insulin, opioids, and narrow therapeutic index drugs.
        Flag: allergies, contraindications, dangerous drug interactions, and doses outside normal range.
        Use the phrase "high risk" in your response if you identify a serious concern.
        Use the phrase "urgent review" if the concern requires same-day pharmacist review.
        """;
}

public sealed record AgentHandoffResult(
    bool   RequiresHumanReview,
    string Content,
    Guid?  ReviewId = null)
{
    public static AgentHandoffResult Completed(string content) =>
        new(false, content);

    public static AgentHandoffResult RequiresHumanReview(Guid reviewId, string message) =>
        new(true, message, reviewId);
}

Safety rules for clinical multi-agent systems:

1. Each agent owns its domain — no cross-domain writes
   PrescriptionAgent can only call prescription tools
   LabResultsAgent can only call lab tools
   Neither can call each other's write functions

2. Orchestrator does not bypass agent safety checks
   Orchestrator asks agents for information/assessment
   It NEVER calls write tools directly — write actions go through specialist agents
   which have their own validation and confirmation logic

3. Agents do not trust each other's output without verification
   If DischargeAgent says "all prescriptions approved", the OrchestratorAgent
   should verify this independently rather than taking the agent's word for it
   (this prevents prompt injection through inter-agent communication)

4. Human escalation is always available
   Any agent can escalate to human review
   No multi-agent chain can complete a high-risk action without human sign-off
   The escalation path must be tested end-to-end

5. Full trace per request
   Every agent invocation, message, tool call, and handoff is logged
   with the same correlation ID — enabling end-to-end audit of any decision