Synergy Agent Platform

Technical Documentation

Document Purpose: Project approval brief for the Synergy multi-agent AI platform. This document covers the proposal rationale, system architecture, agent design, trade-offs, safety model, and implementation roadmap.

0. Executive Summary

Synergy is a case study based PoC to demonstrate the power of multi-agent AI platform built for WebMD Health Corp that houses three specialized AI products, each solving a distinct operational challenge in a regulated healthcare technology environment:

Why now: Healthcare technology organizations face an acute productivity and safety paradox — engineering velocity must increase while regulatory compliance and patient-safety obligations demand higher quality gates. Manual code review, ad-hoc PRD writing, and reactive incident triage are the three biggest drags on WebMD engineering throughput. Synergy eliminates these bottlenecks with AI agents that amplify — not replace — human judgment through structured human-in-the-loop checkpoints.

What this is not: A speculative prototype. Every agent graph, API route, database schema, and safety primitive described in this document is production-quality code, running today on Vercel + Neon Postgres.

1. Proposal & Justification

1.1 Business Problem Statement

Voyager — The Code Review Bottleneck

WebMD engineering teams submit hundreds of PRs monthly. Manual review is time-consuming, inconsistent across reviewers, and creates a compliance risk when reviewers miss HIPAA-relevant data handling patterns. Junior engineers receive delayed feedback; senior engineers spend disproportionate time on review rather than design.

Voyager solves this by performing simultaneous three-dimensional analysis (code quality, documentation completeness, bug/security detection) on any GitHub PR in under 60 seconds, then delivering a structured report that reviewers can act on immediately.

Kite — The PRD Quality Gap

Product requirements documents at WebMD are often written ad-hoc, lack consistent structure, and miss critical acceptance criteria and edge cases for healthcare workflows (e.g., PHI handling, accessibility, fallback states for high-availability requirements). Misaligned requirements discovered late in the development cycle are one of the top sources of rework.

Kite generates comprehensive, structured PRDs from a product idea description, automatically produces acceptance criteria and edge cases with healthcare context, asks targeted clarifying questions, and iterates with the product manager until the document meets their standard — all in a single guided session.

Nucleus — Reactive Incident Response

WebMD's operational environment processes patient health data. Incident response must be fast (patient impact), accurate (avoid mis-remediation), and auditable (regulatory). Current processes involve manual log triage, ad-hoc severity assessment, and runbook lookup — each introducing delay and inconsistency.

Nucleus ingests raw operational logs, classifies incident severity (SEV1–SEV4) with clinical precision, correlates signals across systems, hypothesizes root causes, and for high-severity incidents, auto-generates runbooks in parallel with remediation plans — all while requiring human validation before any action recommendations are finalized.

1.2 Market Context

The healthcare technology sector is experiencing an AI adoption inflection point driven by:

• CMS/ONC regulations mandating interoperability, creating engineering demand
• HIPAA modernization requiring more rigorous data-handling audits in code
• Patient safety obligations demanding faster, more reliable incident response SLAs
• Developer productivity initiatives across digital health companies to compete with consumer tech hiring

Synergy positions WebMD to lead in responsible AI-augmented engineering — not by automating humans out, but by making every human decision better-informed and faster.

1.3 Value Metrics & ROI Narrative

2. Agent & App Architecture

2.1 Platform-Level Architecture

Synergy is a Next.js 15 application deployed on Vercel, using LangGraph for agent orchestration, Neon Postgres for persistence and LangGraph checkpointing, and OpenAI GPT-4o/GPT-4o-mini for intelligence.

2.1.1 Database Schema

2.1.2 SSE Streaming Data Flow

2.2 Voyager — PR Review Agent

Voyager automates GitHub pull request review through a structured multi-stage pipeline with a human-in-the-loop gate for PR selection and parallel analysis execution.

Key capabilities:

• GitHub repository and PR listing via authenticated API calls
• Human-in-the-loop interrupt at PR selection (user chooses which PR to analyze)
• Parallel 3-way analysis: code quality, documentation review, and bug/security detection run simultaneously using LangGraph's Send API
• Structured synthesis report merging all three review dimensions
• Resumable via LangGraph checkpointing — survives server restarts

2.3 Kite — PRD Generator Agent

Kite generates comprehensive, structured PRDs through a sequential generation pipeline followed by a human refinement loop. After a PRD is finalized, subsequent sessions enter a Q&A chat mode with the full document as context.

Key capabilities:

• Structured PRD generation from a plain-language product idea
• Automatic generation of acceptance criteria and edge cases with healthcare context
• Clarifying questions generated to surface unstated assumptions
• Human-in-the-loop interrupt for review, approval, or refinement feedback
• Conditional loop: re-runs generation pipeline with feedback context (max 2 iterations)
• Post-generation chat mode for follow-up questions

2.4 Nucleus — Operational Intelligence Agent

Nucleus provides a full incident analysis pipeline from raw log ingestion through severity classification, signal correlation, root cause hypothesization, and response generation. SEV1/SEV2 incidents trigger parallel runbook + remediation generation for maximum speed.

Key capabilities:

• Multi-format log ingestion (plain text, structured JSON, paste)
• SEV1–SEV4 classification aligned with WebMD incident severity standards
• Signal correlation across multiple log sources
• Root cause hypothesization with confidence scoring
• Human validation interrupt before any remediation recommendations are issued
• Parallel execution for SEV1/SEV2: remediation plan and runbook generated simultaneously
• Post-incident Q&A mode for retrospective analysis

2.5 Shared Infrastructure

All three agents share a common infrastructure layer that provides consistency, performance, and reliability.

3. Trade-offs & Design Decisions

The following decisions reflect deliberate engineering choices with clear rationale for a healthcare-regulated, startup-velocity context.

4. Safety, Governance & Trust

Synergy is designed with defense-in-depth across every layer. In a healthcare technology context, trust is non-negotiable.

4.1 Security Architecture

Session Isolation Every database query is scoped by sessionId (extracted from HTTP-only cookie). A user cannot access another user's conversations, agent states, or outputs. The session cookie is HttpOnly; SameSite=Lax — inaccessible to JavaScript, protected against CSRF.

Rate Limiting A sliding-window rate limiter (20 req/60s per session+operation key) prevents abuse. The in-memory implementation uses a Map with automatic cleanup every 5 minutes to prevent unbounded growth. Phase 4 upgrades this to Redis for distributed enforcement.

Input Validation All API boundaries validate inputs with Zod schemas. Agent node inputs are typed via LangGraph state annotations. There is no string interpolation of user content into system prompts without sanitization.

LLM Safeguards

• temperature=0 on all models — eliminates hallucination variance
• Structured JSON extraction with explicit fallbacks for malformed outputs
• No user content reaches the LLM without explicit prompt templating
• GitHub token access is read-only (repo contents, PRs, diffs) — no write permissions

Audit Trail The agent_runs table records every agent invocation with: input payload, output, error (if any), duration_ms, and a nodeTrace array capturing per-node execution timing. This creates a full audit trail for compliance review.

No PII in Logs Application logs contain no PHI or PII. Log entries reference only IDs (conversationId, sessionId) and node names — never content.

4.2 HIPAA & Healthcare Compliance Considerations

• No PHI processed through agents by design — Nucleus processes operational/infrastructure logs, not patient records
• Data minimization — Only data necessary for the agent task is sent to the LLM
• Audit trail — agent_runs table supports compliance audit requirements
• Access scoping — Session isolation prevents cross-user data leakage
• Roadmap: Phase 5 includes formal HIPAA Business Associate Agreement (BAA) with OpenAI, encryption at rest for Neon Postgres, and an enterprise audit log export feature

5. Project & Implementation Plan

5.1 Current State — What's Built

The following capabilities are fully implemented and functional today:

5.2 Productionalization Roadmap

5.3 Productionalization Maturity Levels

5.4 Scaling Architecture — Future State

5.5 Functional Trustworthiness

A production AI system must be testable, observable, and auditable. Synergy's quality strategy:

Testing Strategy

• Node unit tests: Each agent node is a pure function (input state → output state patch). Test with mock LLM responses.
• Graph integration tests: Full graph execution with test checkpointer and deterministic seeds
• Eval harnesses: Golden dataset of (input, expected_output) pairs evaluated on each PR
• Prompt regression CI: Any prompt change requires eval score ≥ baseline before merge

Observability

• LangSmith (Phase 2) traces every LangGraph invocation with token usage, latency, and intermediate states
• agent_runs.nodeTrace provides per-node timing for P95 latency tracking
• Vercel Analytics + custom metrics for user-facing performance

Human-in-the-Loop as Quality Gate The interrupt pattern is not just UX — it's a quality gate. No action recommendations (remediation steps, PR merge decisions) are issued without explicit human validation. This is the primary safeguard against LLM overconfidence in high-stakes scenarios.

6. Appendix

6.1 Technology Stack Reference

6.2 Environment Configuration

6.3 Key Code Artifacts

LLM Singleton Pattern — prevents redundant model initialization:

// src/lib/agents/shared/llm.ts
let _reasoningModel: ChatOpenAI | null = null;

export function getReasoningModel(): ChatOpenAI {
  if (_reasoningModel) return _reasoningModel;
  _reasoningModel = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
    openAIApiKey: process.env.OPENAI_API_KEY,
  });
  return _reasoningModel;
}

Parallel Fan-out via Send API — Voyager's 3-way parallel review:

// src/lib/agents/voyager/graph.ts
.addConditionalEdges("analyze_diff", (_state) => {
  return [
    new Send("code_quality_review", {}),
    new Send("doc_review", {}),
    new Send("bug_check", {}),
  ];
})

Severity-Conditional Parallel Execution — Nucleus SEV1/2 parallel runbook:

// src/lib/agents/nucleus/graph.ts
.addConditionalEdges("human_validate", (state) => {
  if (state.severity === "SEV1" || state.severity === "SEV2") {
    return [
      new Send("generate_remediation", {}),
      new Send("draft_runbook", {}),
    ];
  }
  return [new Send("generate_remediation", {})];
})

Session-Scoped Rate Limiting:

// src/lib/rate-limit.ts
export function rateLimit(
  key: string,
  limit = 20,
  windowMs = 60_000,
): { success: boolean; remaining: number } {
  // Sliding window — prune timestamps outside current window
  entry.timestamps = entry.timestamps.filter((t) => t > windowStart);
  if (entry.timestamps.length >= limit) return { success: false, remaining: 0 };
  entry.timestamps.push(now);
  return { success: true, remaining: limit - entry.timestamps.length };
}

6.4 Glossary