Regulated medical AI toolchain for clinical AI builders

Bring your model. Ship a governed medical AI product.

Auddax is the harness, SDK, CI system, and governance layer for teams building or deploying model-powered medical products. Your model powers the product experience while Auddax binds each clinical role to enforceable contracts, deterministic logic, validation suites, traceability, and release evidence.

Bring a foundation model API, private deployment, open-weight model, vendor-hosted model, or frozen internal model. Auddax supplies the bounded-role harness, deterministic kernel, validation suite, evidence layer, and release gates around it.

Request technical brief View SDK workflow
Who it's for

For any team bringing models into clinical workflows.

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

  • 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 governed workflows.
  • Digital health products Keep your application surface while Auddax governs clinical behavior underneath.
  • Enterprise AI teams Run model contracts, protocol validation, release evidence, and monitoring through existing CI.
Harness

The model powers the product. Auddax governs the clinical workflow around it.

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 harness, deterministic kernel, release gates, evidence packets, and post-launch traceability required for serious clinical review.

  • Bring-your-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
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
Protocol Library

A clinical library that grows without losing determinism.

Deterministic does not mean static. Auddax protocols are expandable clinical software modules. New protocols can be authored, reviewed, tested, compiled, versioned, and released without turning the diagnostic pathway back into open-ended model generation.

Auddax maintains a growing library of deterministic protocol modules developed with clinical review and grounded in referenced guidelines, care pathways, and safety requirements. Each protocol defines its intended use, supported population, required facts, exclusion criteria, red flags, output states, and trace requirements.

Customers can add protocols through the same governed release path used by the Auddax library: source anchoring, clinician review, simulation, safety gates, behavior diffing, evidence generation, release signoff, and post-launch monitoring.

  • Auddax-maintained library Clinician-reviewed modules for common diagnostic and triage workflows.
  • Customer-authored extensions Institution-specific and product-specific protocols enter the same governed release path.
  • Source anchored Every rule links to a guideline, protocol, policy, or clinical rationale.
  • Compiled and tested Protocols become deterministic runtime artifacts with coverage for rules, red flags, exclusions, and states.
  • Diffed and versioned Every release shows what clinical behavior changed and every encounter records the exact version used.
  • Scoped Protocols define where they apply and where they must hand off.
protocol supply chain governed release path 
$ auddax protocol create adult_sinusitis --template diagnostic_pathway
created protocols/adult_sinusitis.ax
created evals/adult_sinusitis/red_flags.yaml
created sources/adult_sinusitis.bib

$ auddax protocol lint protocols/adult_sinusitis.ax --require-sources
rules: 64
source_anchored: 64
missing_rationale: 0
clinical_review_required: true

$ auddax release diff adult_sinusitis@0.1.0..adult_sinusitis@0.2.0
changed_questions: 4
changed_dispositions: 2
new_exclusions: 1
requires_signoff: clinical, safety
Clinical kernel

Start with a clinical kernel. Extend it through governed code.

Auddax executes protocol modules as deterministic runtime artifacts, whether they come from the Auddax-maintained library or a customer-authored extension. Teams can encode guideline logic, define exclusions, require minimum evidence, set escalation rules, and compile behavior into testable releases.

  • Unknown state Unknown is an explicit state, not a model failure.
  • Scope routing Unsupported presentations are routed out of scope.
  • Red flags Red flags are monotonic and cannot be talked down by the model.
  • Replay Protocol behavior can be replayed across model, prompt, and rule versions.
  • Release diff Every release has a diff showing what clinical behavior changed.
protocol compiler signoff required 
$ auddax protocol compile protocols/chest_pain.ax --target release
protocol: chest_pain
version: 0.4.0
artifact: .auddax/build/chest_pain@0.4.0/kernel.json
rules: 118
red_flags: 23
unsupported_routes: 9
required_facts: 31
result: compiled

$ auddax release diff chest_pain@0.3.2..chest_pain@0.4.0
clinical_deltas: 7
new_escalations: 3
removed_escalations: 0
out_of_scope_routes: +2
signoff_required: clinical
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, model upgrades, and output-composer changes 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.

Layer What is tested Example gate
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
model upgrade lab clinical 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 case forge --suite chest_pain_regression --include vague,missing_facts,contradiction,prompt_injection
generated_cases: 184
rare_red_flags: 23
demographic_strata: 18
prompt_injection_cases: 31
added_to: evals/chest_pain_regression.yaml
Trace

Every customer product output gets a replayable trace.

For every encounter, Auddax records the customer surface, model version, contract, prompt version, source facts, provenance, protocol version, rule path, safety gates, unanswered questions, final output state, and clinician override. Teams can replay a case exactly, compare it against a new release, and show why the system behaved the way it did.

Source

Customer UI events, patient language, and record evidence become provenance-linked facts.

Contract

Model outputs are checked against role scope before clinical logic sees them.

Output

Approved states, language, and evidence can be replayed against future releases.

trace explain replayable 
$ auddax trace show enc_8f31 --explain
encounter: enc_8f31
run: run_20260507_143822
surface: customer_mobile_triage
model_role: intake.extractor
contract: intake.extractor@adult_uti
prompt: intake.extractor@12
protocol: urinary_symptoms@1.8.1
state: urgent_clinician_review

supporting_facts:
  - id: f_021
    type: fever
    value: present
    source: patient_report
    confidence: 0.94
  - id: f_024
    type: flank_pain
    value: present
    source: patient_report
    confidence: 0.91

unanswered:
  - pregnancy_status

rule_path:
  - red_flag.pyelonephritis_risk matched [f_021, f_024]
  - required_fact.pregnancy_status unknown
  - disposition.urgent_clinician_review emitted
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 governed sandboxes, 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.

  • 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 governed product

A generative model can power the interface. Auddax governs the product around it.

Auddax gives clinical AI builders the infrastructure to make model-powered medical products bounded, deterministic, traceable, and reviewable. The model can handle language and interaction. Auddax governs model contracts, deterministic decisions, safety gates, traceability, release evidence, and post-launch monitoring.

Request technical brief Talk to the team

Auddax

Regulated medical AI toolchain for clinical AI builders.

brief@auddax.ai