TrialMatch: Why Precision Matters When Lives Are on the Line

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

A few months ago, a friend’s aunt was diagnosed with advanced non-small cell lung cancer. First-line platinum chemotherapy had stopped working. The oncologist said something that stuck with me: "Our best shot right now is an experimental targeted trial. Go home, search ClinicalTrials.gov, and see what you can find."

If you have never searched ClinicalTrials.gov during a medical crisis, the experience is overwhelming. The registry contains more than 450,000 studies written in legalistic clinical language. Each protocol has dozens of eligibility criteria, negative exclusion clauses, and washout windows spread across 40-page PDF attachments.

Like many developers, my first reflex was to see if an AI could help. I pasted the patient’s pathology summary into ChatGPT and Gemini:

58-year-old female, Stage IV NSCLC, EGFR Exon 20 insertion, progressed after carboplatin/pemetrexed, seeking recruiting Phase 2 trials in Texas.

The response was fluent and confident. It returned hospital locations, drug mechanisms, and two clinical trial identifiers: NCT04847387 and NCT04746654.

When I checked them against official registries, neither trial existed. The model had synthesized oncology vocabulary and generated fake 8-digit numbers. In casual creative writing, a hallucination is harmless. In oncology, a fabricated study sends a desperate family chasing dead ends.

Next, I tested standard keyword search. It returned 69 trials matching "EGFR" and "chemotherapy." But manual review showed that 31 of them had explicit exclusion clauses disqualifying anyone with prior systemic chemotherapy. If a patient traveled to Houston based on that search, they would be turned away at the clinic door. Worse, keyword search matched unrelated kidney studies because the filtration test eGFR shares letters with the oncogene EGFR.

That made the underlying technical issue obvious:

Medical safety cannot be solved with flat text search or unstructured prompts. Clinical eligibility depends on strict Boolean rules, exact allele variants, and line-of-therapy sequences. AI needs a structured content lake as an epistemic anchor.

I built TrialMatch: an open-source clinical trial discovery and safety verification agent powered by Sanity Context MCP and deterministic GROQ queries.

Instead of letting an LLM guess against text chunks or vector similarity, TrialMatch anchors the agent to Sanity. Claude Haiku 4.5 parses unstructured patient notes into clean clinical filters. Those filters become deterministic GROQ queries that run against structured Sanity schemas and protocol rules stored in a Sanity Knowledge Base.

System Architecture

sequenceDiagram
    autonumber
    actor Clinician as Clinician / Patient
    participant UI as TrialMatch Web App (Next.js 16)
    participant Agent as Claude Haiku 4.5 (Schema Extractor)
    participant MCP as Sanity Context MCP (trialmatch)
    participant Lake as Sanity Content Lake (Project 6xsr2k42)
    participant KB as Sanity Knowledge Base (trialmatch-kb)

    Clinician->>UI: Enter Patient Note ("58yo NSCLC, EGFR Exon 20, prior chemo, TX")
    UI->>Agent: Extract Clinical Primitives
    Note over Agent: Converts narrative into:<br/>condition="Lung", biomarker="EGFR",<br/>chemo="ALLOWED", state="TX"
    Agent->>MCP: Dispatch GROQ Query with Bound Parameters
    MCP->>KB: Check Washout & Hierarchy Rules
    KB-->>MCP: Rule Verified (Chemo permitted post-progression)
    MCP->>Lake: Execute Deterministic GROQ Filter
    Lake-->>MCP: Return 2 Verified Recruiting Protocols
    MCP-->>UI: Return Match Set + Full GROQ Audit Trace
    UI-->>Clinician: Render Verified Cards + Side-by-Side Hazard Analysis

Demo

• Live Application: trialmatch-oncology.vercel.app
• 3-Arm Benchmark Dashboard: trialmatch-oncology.vercel.app/benchmark
• Hosted Sanity Studio: trialmatch-oncology.sanity.studio

The Duel Arena: Side-by-Side Reality

The web application lets users enter any patient profile or select from eight common clinical presets:

• Left Column (Sanity Context Agent): Returns only verified, recruiting trials. Each card identifies the target biomarker match, lists confirmed hospital sites, and includes an expandable drawer showing the exact GROQ query executed against Sanity.
• Right Column (Naive Keyword Baseline): Shows what traditional keyword search returns. A warning banner details the safety violations, explaining why specific trials are clinically disqualified (such as prior chemotherapy bans or active liver metastases).
• Column-Level Pagination: When keyword search returns 69 studies and the Sanity agent returns 2, each column paginates independently (6 trials per page) with centered navigation controls (< Page 1 of 12 >). This keeps the comparison readable without infinite page scrolling.

Code

• GitHub Repository: github.com/IshekKhal/trialmatch

Project Layout

trialmatch/
├── app/
│   ├── page.tsx               # The Duel Arena (Sanity Agent vs Keyword Baseline)
│   ├── benchmark/page.tsx     # 3-Arm Evaluation Dashboard
│   ├── layout.tsx             # Root layout with Geist font tokens
│   ├── globals.css            # Medical obsidian styling (#080C14)
│   └── api/
│       ├── duel/route.ts      # Live duel execution endpoint
│       ├── benchmark/route.ts # 3-arm benchmark evaluation API
│       └── trials/route.ts    # Normalized clinical trial fetcher
├── components/
│   ├── DuelArena.tsx          # Dual-column comparison with column-level pagination
│   ├── ScenarioChips.tsx      # 8 pre-configured oncology clinical scenarios
│   ├── BenchmarkRunner.tsx    # Interactive benchmark runner & case inspector
│   ├── BenchmarkTable.tsx     # 10-patient audit breakdown table
│   └── Scoreboard.tsx         # Real-time comparative metric display
├── studio/
│   ├── sanity.config.ts       # Sanity Studio v3 configuration
│   └── schemas/
│       ├── clinicalTrial.ts   # Core schema: biomarkers, therapy rules, facilities
│       ├── protocolRule.ts    # Knowledge base schema: exclusion overrides & washouts
│       └── index.ts           # Schema registry
├── lib/
│   ├── agent.ts               # Claude Haiku 4.5 schema extractor & GROQ builder
│   ├── sanity.ts              # Sanity client & live Context MCP bindings
│   ├── eval_cases.ts          # 10 gold-standard oncology test profiles
│   ├── eval_runner.ts         # Automated 3-arm benchmark execution engine
│   └── types.ts               # TypeScript domain interfaces
├── scripts/
│   ├── ingest_trials.ts       # ClinicalTrials.gov API v2 data ingestion pipeline
│   └── run_eval.ts            # CLI benchmark evaluation runner
└── data/
    ├── trials_normalized.json # 100 curated oncology trials (1.2 MB)
    ├── eval_results.json      # Raw 3-arm benchmark evaluation outputs
    └── eval_summary.md        # Comprehensive 419-line benchmark report

How I Used Sanity

1. Modeling Oncology Beyond Text Blobs

Oncology protocols cannot live in free-text fields. A single protocol contains dozens of technical, medical, and pharmacokinetic constraints.

In Sanity Studio (studio/schemas/clinicalTrial.ts), I modeled trials into structured primitives:

• targetBiomarkers: Typed string array (EGFR, KRAS, BRAF, HER2, BRCA1, Exon 20, G12C, V600E).
• priorTherapyRules: An object with explicit status enums (REQUIRED, ALLOWED, EXCLUDED, ANY) for chemotherapy, immunotherapy, and targeted therapies.
• locations: Array of facility objects with city, state, and hospital names across 1,144 US sites.
• eligibilityCriteria: Structured inclusion and exclusion bullet points.

Clinical Trial Protocol Schema (studio/schemas/clinicalTrial.ts)

import {defineField, defineType} from 'sanity'

export default defineType({
  name: 'clinicalTrial',
  title: 'Clinical Trial',
  type: 'document',
  fields: [
    defineField({
      name: 'nctId',
      title: 'NCT ID',
      type: 'string',
      validation: (Rule) => Rule.required(),
    }),
    defineField({
      name: 'briefTitle',
      title: 'Brief Title',
      type: 'string',
      validation: (Rule) => Rule.required(),
    }),
    defineField({
      name: 'recruitmentStatus',
      title: 'Recruitment Status',
      type: 'string',
      options: {
        list: [
          {title: 'Recruiting', value: 'RECRUITING'},
          {title: 'Active, Not Recruiting', value: 'ACTIVE_NOT_RECRUITING'},
        ],
      },
    }),
    defineField({
      name: 'primaryCondition',
      title: 'Primary Condition',
      type: 'string',
      validation: (Rule) => Rule.required(),
    }),
    defineField({
      name: 'targetBiomarkers',
      title: 'Target Biomarkers',
      type: 'array',
      of: [{type: 'string'}],
      options: {
        list: ['EGFR', 'KRAS', 'BRAF', 'HER2', 'ALK', 'BRCA1', 'BRCA2', 'Exon 20', 'G12C', 'V600E'],
      },
    }),
    defineField({
      name: 'priorTherapyRules',
      title: 'Prior Therapy Rules',
      type: 'object',
      fields: [
        defineField({
          name: 'chemotherapy',
          type: 'string',
          options: { list: ['REQUIRED', 'ALLOWED', 'EXCLUDED', 'ANY'] },
        }),
        defineField({
          name: 'immunotherapy',
          type: 'string',
          options: { list: ['REQUIRED', 'ALLOWED', 'EXCLUDED', 'ANY'] },
        }),
      ],
    }),
    defineField({
      name: 'locations',
      title: 'Trial Locations',
      type: 'array',
      of: [{
        type: 'object',
        fields: [
          { name: 'facility', type: 'string' },
          { name: 'city', type: 'string' },
          { name: 'state', type: 'string' },
          { name: 'country', type: 'string' },
        ],
      }],
    }),
  ],
})

To handle clinical edge cases (such as whether past chemotherapy represents a permanent exclusion or simply requires a 30-day washout window), I created a companion schema, protocolRule.ts, indexed in the Sanity Knowledge Base:

Protocol Guidance Rule Schema (studio/schemas/protocolRule.ts)

import {defineField, defineType} from 'sanity'

export default defineType({
  name: 'protocolRule',
  title: 'Clinical Protocol Interpretation Rule',
  type: 'document',
  fields: [
    defineField({ name: 'ruleId', title: 'Rule ID', type: 'string' }),
    defineField({ name: 'title', title: 'Rule Title', type: 'string' }),
    defineField({
      name: 'category',
      type: 'string',
      options: {
        list: [
          {title: 'Eligibility Hierarchy', value: 'ELIGIBILITY_HIERARCHY'},
          {title: 'Washout Periods', value: 'WASHOUT_PERIODS'},
          {title: 'Biomarker Specificity', value: 'BIOMARKER_SPECIFICITY'},
        ],
      },
    }),
    defineField({ name: 'priority', title: 'Priority (1-10)', type: 'number' }),
    defineField({ name: 'summary', title: 'Rule Summary', type: 'text' }),
    defineField({ name: 'clinicalRationale', title: 'Clinical Rationale', type: 'text' }),
  ],
})

2. Sanity Context MCP Endpoints

We connected our Sanity Content Lake through two dedicated Sanity Context MCP endpoints:

1. GROQ Context Endpoint (trialmatch): Exposes the live dataset for parameterized GROQ queries.
2. Knowledge Base Endpoint (trialmatch-kb): Provides semantic retrieval over protocol interpretation rules.

When a patient note arrives, the agent translates the clinical parameters into this exact GROQ query:

*[_type == "clinicalTrial" && 
  recruitmentStatus == "RECRUITING" && 
  primaryCondition match $condition && 
  targetBiomarkers[] match $biomarker && 
  (priorTherapyRules.chemotherapy == "ALLOWED" || 
   priorTherapyRules.chemotherapy == "REQUIRED" || 
   priorTherapyRules.chemotherapy == "ANY") && 
  locations[].state match $state] {
    nctId,
    briefTitle,
    phase,
    primaryCondition,
    targetBiomarkers,
    priorTherapyRules,
    "matchingLocations": locations[state match $state]
}

Because priorTherapyRules.chemotherapy is an explicit schema property, Sanity filters out the 67 trials that forbid prior chemotherapy before any result reaches the user.

3. The 3-Arm Benchmark: Empirical Findings

To verify whether structured content changes clinical outcomes, I built an evaluation suite (lib/eval_runner.ts) and tested ten gold-standard oncology profiles across three discovery approaches:

4. Real Clinical Failure Modes

Examining individual patient cases demonstrates where unstructured search breaks down:

1. Chemotherapy Exclusion (Case TC-01)

• Patient: 58yo female, NSCLC EGFR Exon 20 insertion, prior platinum chemotherapy, Texas.
• Keyword Failure: Returned 69 trials. 31 violated safety rules. Trial NCT07799935 specifically prohibits prior systemic chemotherapy in Rule 14.
• Bare LLM Failure: Hallucinated trials NCT04847387 and NCT04746654. Neither identifier exists.
• Sanity Result: Executed GROQ checking priorTherapyRules.chemotherapy in ["ALLOWED", "REQUIRED", "ANY"]. Safely returned exactly 2 verified trials.

2. Organ Site Metastasis Contraindications (Case TC-02)

• Patient: 62yo male, Stage IV colorectal cancer, KRAS G12C mutation, stable liver metastases, California.
• Keyword Failure: Matched trial NCT05286814 because the document contained the word "metastases," failing to catch that active hepatic involvement was an explicit disqualification.
• Bare LLM Failure: Hallucinated trials NCT04793958 and NCT04685141.
• Sanity Result: Evaluated structured exclusion rules in Sanity's Knowledge Base, preventing the false match.

3. Quantitative Biomarker Expression Cutoffs (Case TC-03)

• Patient: 51yo female, HER2-low (IHC 1+ or IHC 2+/FISH negative) metastatic breast cancer.
• Keyword Failure: Returned 72 trials, including NCT04281641 and NCT02945579 which strictly require high HER2 overexpression (IHC 3+).
• Sanity Result: Cleanly separated HER2-overexpressing protocols from novel HER2-low antibody-drug conjugate trials.

4. Phase 3 Confirmatory Requirement (Case TC-04)

• Patient: 47yo patient, unresectable Stage IIIC melanoma, BRAF V600E mutation, seeking Phase 3 trials in New York.
• Keyword Failure: Returned 30 trials, 26 of which were Phase 1 dose-escalation trials with unknown toxicities.
• Sanity Result: Strict GROQ filter phase == "PHASE3" isolated the single qualifying Phase 3 confirmatory study.

Sanity Project Details

• Project ID: 6xsr2k42
• Dataset: production
• Hosted Studio: trialmatch-oncology.sanity.studio
• Sanity GROQ MCP Endpoint: https://api.sanity.io/v1/context/organizations/oz3yptidu/mcp/trialmatch
• Sanity Knowledge Base MCP Endpoint: https://api.sanity.io/v1/context/organizations/oz3yptidu/mcp/trialmatch-kb
• Public Sample Query (Live JSON): Live 3-Trial Sanity Query Endpoint

Agent Session

Below is a representative excerpt from the agent's interaction loop with Sanity Context MCP:

Clinician:
"We have a 58yo patient with NSCLC harboring an EGFR Exon 20 insertion.
She progressed on carboplatin/pemetrexed. Find recruiting Phase 2 trials
in Texas that permit prior chemotherapy."

Agent (Claude Haiku 4.5):
Extracting clinical parameters:
- Condition: "Lung" (NSCLC)
- Target Biomarker: "EGFR", "Exon 20"
- Chemotherapy: "ALLOWED" or "REQUIRED"
- Location: "TX"
- Recruitment Status: "RECRUITING"

Tool Call -> Sanity Context MCP (trialmatch):
GROQ: *[_type == "clinicalTrial" && recruitmentStatus == "RECRUITING"
         && primaryCondition match "Lung"
         && targetBiomarkers[] match "EGFR"
         && (priorTherapyRules.chemotherapy == "ALLOWED" || 
             priorTherapyRules.chemotherapy == "REQUIRED")
         && locations[].state match "TX"]{nctId, briefTitle, phase}

MCP Response:
[
  {
    "nctId": "NCT05376891",
    "briefTitle": "Phase 2 Study of Targeted EGFR Exon 20 Inhibitor",
    "phase": "PHASE2"
  },
  {
    "nctId": "NCT06234137",
    "briefTitle": "Targeted Kinase Therapy for Relapsed EGFR Mutations",
    "phase": "PHASE2"
  }
]

Verification: 2 active matches found. 0 safety exclusions violated. 0 hallucinations.

What This Demonstrates

The software industry has spent two years hoping that larger foundation models or clever prompting would eliminate hallucinations. But in medicine, accuracy is not a fuzzy percentage; it is a binary safety gate.

Connecting an AI agent to structured content in Sanity transforms the language model from an unreliable generator into a deterministic parser. The model extracts the patient's intent, Sanity executes the Boolean protocol constraints, and the patient receives verified, life-saving options.

Structured content is not merely a content management pattern. In high-stakes domains, structured content is the safety layer AI cannot function without.