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.

GitMed powers the protocol supply chain behind that library: Protocol Studio, Case Forge, release diffs, clinical review, source anchoring, signoff, and registry records for every deterministic module.

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.

Explore GitMed

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 and localized Deterministic overlays adapt base protocols by country, state, payer, health system, or care setting without forking the pathway.

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

Auddax SignalOS

Turn external signals into admissible clinical facts.

SignalOS is the governed data layer for medical AI products. It takes patient-reported information, device streams, wearables, EHR fields, labs, and customer-owned data feeds and converts them into provenance-linked facts with explicit clinical permissions.

Each signal is normalized, quality-scored, source-anchored, and evaluated against the workflow, model role, protocol requirements, patient state, and decision boundary. A signal can support context, require confirmation, qualify for triage, or be excluded from decisioning without disappearing from the trace.

Normalize Units, timestamps, source metadata, device class, and sampling windows become consistent facts.
Admit Signals receive workflow-specific permissions for context, triage, confirmation, or exclusion.
Monitor Longitudinal baselines, drift, missingness, and anomaly patterns become governed review inputs.
Trace Every admitted or excluded fact keeps its source, transformation, confidence, and decision boundary.

signal admissibility permissions assigned

$ auddax signal admit apple_health:heart_rate \
  --workflow chest_pain_triage \
  --protocol chest_pain@2.4.0
signal: heart_rate
source: apple_watch
observed_at: 2026-05-13T14:22:00Z
normalized:
  value: 92
  unit: bpm
quality:
  device_class: consumer_wearable
  sampling: intermittent
  confidence: 0.62
context:
  freshness: 3m
  patient_state: resting_unknown
admissibility:
  context: allowed
  triage: requires_confirmation
  disposition: excluded

reason:
  - sampling_quality_below_disposition_threshold
  - patient_state_unconfirmed

emitted_fact:
  id: wearable_heart_rate.current
  permission: context
  trace: sig_62f9

SignalOS Vault

Govern sensitive datasets without taking custody of the plaintext.

Some clinical AI products need to use high-sensitivity data: genomics, omics, research cohorts, longitudinal records, imaging-derived measurements, or customer-owned data extracts. SignalOS Vault lets those datasets participate in Auddax workflows through signed manifests, consent scope, custody attestations, privacy-risk gates, and admissibility decisions instead of raw data transfer.

Customers can keep keys and plaintext inside their own environment while Auddax verifies the manifest, consent status, privacy-risk checks, and allowed use. The result is a governed data supply chain for validation, monitoring, model evaluation, and clinical workflows that need sensitive evidence without expanding Auddax's custody boundary.

Signed manifests Every dataset or extract carries hashes, source identity, schema, custody mode, and allowed use.
Consent scope Use is checked against scoped, revocable consent before data can support a workflow or release.
Privacy gate Cohort size, rare-feature exposure, linkage risk, and reviewer signoff become build gates.
Custody boundary Auddax can govern evidence and permissions while customers retain plaintext and key custody.

sensitive data gate manifest verified

$ auddax vault register genomic_cohort:cardio_hcm \
  --manifest manifests/cardio_hcm.v1.json \
  --custody customer_kms \
  --use validation.regression
manifest: vault_manifest_7c41
plaintext_visible_to_auddax: false
custody:
  keys: customer_kms
  data_plane: customer_cloud
consent:
  scope: validation, monitoring
  revoked_records: 0
privacy_gate:
  k_anonymity: pass
  rare_feature_suppression: pass
  linkage_risk: review_required
admissibility:
  model_training: excluded
  evaluation: allowed
  runtime_context: requires_confirmed_scope
evidence: clearanceos/vault/cardio_hcm.v1

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, SignalOS mappings, Vault privacy-risk gates, and output-composer changes can fail before they reach patients or clinicians. GitMed supplies the protocol release diffs, source checks, sparring cases, and clinical signoffs that make protocol changes reviewable. 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, signal mapping, Vault manifest, privacy-risk gate, 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 governed 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, signal mapping, Vault manifest, and composer edits	Approved boundary or higher review
Vault	Consent scope, custody boundary, privacy risk, and manifest integrity	Sensitive data blocked unless use is permitted
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
changed:
  - model: customer:triage-v7-frozen -> azure-openai:gpt-5.5
  - output_composer: 3.1.0 -> 3.2.0
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 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

$ 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

Trace / Responsibility

Every output gets a responsibility graph and replayable trace.

For every encounter, Auddax records the customer surface, model version, contract, prompt version, SignalOS facts, Vault manifests, 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.

The trace also clarifies accountability: which party supplied the model, which protocol made the clinical decision, which data source contributed each fact, which clinician confirmed or overrode it, and which component generated the final wording. If a case is escalated, Auddax can reconstruct the workflow as a regulator-ready incident packet.

Source

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

Responsibility

Models, protocols, data sources, clinicians, and composers each keep explicit boundaries.

Incident

Escalated cases can be replayed into complete evidence packets for review.

responsibility graph packet ready

$ auddax graph show enc_8f31 --responsibility
encounter: enc_8f31
run: run_20260507_143822
surface: customer_mobile_triage
release: candidate-2026.05.07

responsibility:
  customer_app:
    surface: mobile_triage
    collected: patient_report, ehr.medications
  signalos:
    admitted: patient_report.symptom_duration
    excluded: apple_watch.heart_rate_for_disposition
    reason: sampling_quality_below_threshold
  vault:
    manifest: vault_manifest_7c41
    consent_scope: validation, monitoring
    privacy_gate: review_required
  model_provider:
    model: azure-openai:gpt-5.5
    role: intake.extractor
    emitted: f_021, f_024
  auddax:
    contract: intake.extractor@adult_uti
    protocol: urinary_symptoms@1.8.1
    rule_path: red_flag.pyelonephritis_risk
    state: urgent_clinician_review
  clinician:
    review: pending
    override: none
  output_composer:
    version: output.composer@4
    final_wording: approved_template.urgent_review

$ auddax incident replay enc_8f31 --packet regulator
packet: incident_enc_8f31.zip
includes:
  - model_calls
  - source_facts
  - admissibility_decisions
  - protocol_path
  - output_composer
  - release_manifest

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.

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.
Benchmark scope Compare model-role performance against de-identified suites for safety, language, and subgroup gaps.
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
  benchmark_delta:
    pediatric_negation: -3.4%
    spanish_duration: -2.1%
  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