Auddax Harness

Bring your own model. Prove what it does.

Auddax Harness sits underneath your product and keeps a reviewable record of what your model did and why. Deterministic logic decides the clinical steps, so the same case always produces the same answer, and every encounter becomes something you can show a clinician, a customer, or a regulator.

Bring a foundation model API, private deployment, open-weight model, vendor-hosted model, or frozen internal model. Auddax limits what your model is allowed to say, tests it every time you change it, and produces the evidence your reviewers will ask for before launch.

Request technical brief View SDK workflow
Harness

The model powers the product. Auddax makes its clinical behavior reviewable.

Auddax sits beneath a customer's medical AI interface as the bounded runtime for clinical behavior. The customer brings the model, product surface, and user experience. Auddax supplies the role limits, deterministic kernel, release gates, and audit trail that let anyone reconstruct why the product said what it said.

This is the counterpart to the Auddax API. Call the API when you want MedCanon's clinical engine to run the encounter for you. Use the Harness when you are bringing your own model and need to prove it is safe before you can launch.

  • Bring-your-own-model runtime Attach a hosted foundation model API, private endpoint, open-weight model, or frozen internal model to a bounded role.
  • Customer-owned surface Keep your app, chat, agent, EHR workflow, or API while Auddax governs the clinical pathway.
  • Deterministic kernel Evaluate scope, evidence sufficiency, red flags, contraindications, and approved output states.
  • Release evidence layer Produce replayable evidence for safety review, enterprise procurement, and regulated release.
  • Customer APIs and SDKs Expose contracts, traces, simulations, and safe output composition inside your own stack.
workspace seed customer-owned product 
$ auddax workspace init customer-triage \
    --model private:endpoint/clinical-nlp-v3 \
    --surface hosted-api
workspace: customer-triage
model_runtime: private:endpoint/clinical-nlp-v3
product_surface: customer_owned
supported_model_sources:
  - hosted_foundation_model
  - private_deployment
  - open_weight_model
  - frozen_internal_model
clinical_kernel: auddax://protocols/respiratory_triage@0.1.0
contracts: enabled
clinical_ci: enabled
sdk: typescript
evidence: required_before_release
Who it's for

For any team bringing models into clinical workflows.

The Harness is built for organizations that need model-powered medical products to behave like real clinical software. That includes foundation model providers, health systems, digital health products, care navigation platforms, EHR-connected products, payers, and internal enterprise AI teams.

Regulatory clearance is one reason teams want this. More often it is the everyday work: explaining a specific answer to a clinician, catching behavior drift after a model upgrade, getting an enterprise customer through security review, or giving clinical leadership something to sign off on before launch.

  • Model providers Qualify hosted foundation models for bounded clinical roles and product integrations.
  • Health systems Bring a vendor model, private deployment, or frozen internal model into a controlled clinical workflow.
  • Digital health products Keep your application surface while Auddax keeps clinical behavior inside approved limits.
  • Enterprise AI teams Run model contracts, protocol validation, release evidence, and monitoring through existing CI.
Contracts

Model contracts turn any clinical model role into a reviewable component.

Each model role has an enforceable contract: allowed inputs, allowed outputs, blocked claims, schema, escalation behavior, and quarantine behavior. A model can extract facts, summarize evidence, or compose approved language only inside the role it has been qualified to perform.

  • Allowed inputs Define the encounter context, source evidence, and protocol state each role may see.
  • Allowed outputs Constrain the role to facts, uncertainty, source spans, summaries, or approved text.
  • Blocked claims Prevent diagnosis, disposition, treatment plans, or ungrounded advice from the wrong role.
  • Escalation behavior Route uncertainty, missing facts, red flags, and scope violations to the right state.
  • Quarantine Capture violations as evidence instead of letting unsupported output reach the product.
model contract enforced 
$ auddax contract create customer:triage-v7-frozen \
    --role intake.extractor --scope adult_uti
contract: intake.extractor@adult_uti
model: customer:triage-v7-frozen
may_emit:
  - facts
  - uncertainty
  - source_spans
blocked:
  - diagnosis
  - disposition
  - treatment_plan
violation_action: quarantine
Clinical CI/CD

Medical AI safety becomes a build gate.

Auddax runs in GitHub Actions, GitLab, Buildkite, or internal CI so protocol edits, prompt changes, and model upgrades can fail before they reach patients or clinicians. The result is a repeatable qualification workflow for teams that upgrade models as part of normal product development.

Change plans become executable policy. When a model, prompt, protocol, threshold, or output composer changes, Auddax classifies the change, identifies required evidence, runs the right validation suite, and determines whether the release remains inside the approved change boundary.

After launch, clinician overrides and disagreements can be clustered into tracked improvement work: protocol-change candidates, new test cases, and model-role evaluation gaps.

Layer What is tested Example gate
Change plan Model, prompt, protocol, threshold, and composer edits Approved boundary or higher review
Contracts Model roles stay inside allowed schema and claims Zero blocked outputs from intake role
Upgrade lab New model versions replay against approved suites No missed red flags or unsupported claims
Case forge Adversarial, vague, missing, contradictory, and rare cases Red-team suite must pass before release
Subgroups Behavior across demographic strata, language, and environment Qualified scope remains explicit
Evidence Behavior change is reviewed and reproducible Signoff required for clinical deltas
Overrides Clinician disagreement and override clusters New tests or protocol-change candidates
model upgrade lab clinical review required 
$ auddax change classify candidate-2026.05.07 \
    --plan approved_change_boundary
change_class: significant_model_component_update
required_evidence:
  - regression_suite
  - behavior_diff
  - clinical_signoff
inside_boundary: false
release_gate: higher_review_required

$ auddax model compare customer:triage-v7-frozen \
    azure-openai:gpt-5.5 --suite chest_pain_regression
extraction_delta: +2.8%
unsupported_claims: 0
missed_red_flags: 0
changed_dispositions: 3
release_gate: clinical_review_required

$ auddax overrides cluster --since release:candidate-2026.05.07
override_clusters: 6
new_test_candidates: 18
protocol_change_candidates: 3
model_role_eval_gaps: 4
SDK

APIs, SDKs, and CLI workflows for customer-owned products.

Clinical AI builders can embed Auddax below their own product surface. Generate typed clients, run sandboxed test encounters, attach models from multiple sources, validate model upgrades, and export release evidence without forcing users into an Auddax-branded clinical application.

customer sdk workflow embeddable 
auddax sdk generate --language typescript --roles intake.extractor,output.composer
auddax model attach azure-openai:gpt-5.5 --role intake.extractor
auddax model attach customer:triage-v7-frozen --role output.composer
auddax sandbox run --model private:endpoint/clinical-nlp-v3 --protocol urinary_symptoms@1.8.1
auddax contract create customer:triage-v7-frozen --role intake.extractor --scope adult_uti
auddax model compare customer:triage-v7-frozen azure-openai:gpt-5.5 --suite chest_pain_regression
auddax case forge --suite red_flags --include vague,contradiction,missing_facts
auddax release validate candidate-2026.05.07
auddax evidence build candidate-2026.05.07 --out .auddax/evidence/
auddax deploy promote candidate-2026.05.07 --env staging
Model Qualification Registry

A model version is approved only for the roles it has earned.

Auddax tracks which model versions are qualified for which clinical roles, conditions, populations, languages, environments, and release channels. Hosted foundation models, private deployments, fine-tuned models, open-weight models, and frozen internal models can each be qualified only for the scopes they have earned.

Where configured, teams can compare role-specific model behavior against shared de-identified benchmark suites without exposing PHI or proprietary data.

  • Model source Qualify hosted, private, open-weight, fine-tuned, or frozen internal models through one registry.
  • Role scope Qualify models separately for intake, summarization, protocol support, and output composition.
  • Clinical scope Bind approvals to conditions, protocols, intended use, and escalation pathways.
  • Population scope Track adult, pediatric, pregnancy, language, geography, and environment qualifications.
  • Release channels Separate sandbox, staging, pilot, and production approvals.
  • Launch monitoring Watch drift, overrides, out-of-scope cases, and threshold breaches after deployment.
qualification registry scoped approval 
$ auddax registry qualify customer:triage-v7-frozen \
    --role intake.extractor --protocol urinary_symptoms@1.8.1
qualified_for:
  model_source: frozen_internal_model
  role: intake.extractor
  conditions:
    - adult_uti
    - urinary_symptoms
  populations:
    - adult
  languages:
    - en-US
    - es-US
  environments:
    - staging
requires_review:
  - output.composer
  - pediatric
  - pregnancy
From medical demo to provable product

Ship the model you already trust, with the record to back it up.

Keep the model and the product surface you already own, and add the role limits, CI gates, qualification registry, and audit trail that let you answer "why did it say that" months later. If you would rather call a ready-made clinical engine than bring your own model, start with the Auddax API instead.

Request technical brief View SDK workflow Explore the API