The clinical engine for medical AI products

Build clinically capable AI with one API.

POST /v1/intakes/{encounter_id}/turns 200 OK
Request 
$ curl https://api.auddax.ai/v1/intakes/turns \
  -H "Authorization: Bearer $AUDDAX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Chest pressure for an hour,
    sweating and short of breath"
  }'
Response 
{
  "safety_status": "cannot_miss_positive",
  "disposition": "emergency_evaluation",
  "next_action": "call_911",
  "terminal": true,
  "trace_id": "trace_8f31"
}

Abridged real responses. See the docs for the full schema.

Auddax gives applications, agents, and model providers access to MedCanon's protocol-grounded clinical engine. Send patient language and context. Receive the next best question, safety disposition, structured clinical state, clinician handoff, and a replayable trace.

Get an API key Read the docs
Clinical API outputs

One API. Clinically useful outputs.

Auddax is designed around the work a clinical product needs to complete, not simply the text a model can generate. Every response moves the encounter forward inside an approved protocol and returns structured state your application can use.

  • Adaptive questions Ask the next protocol-specific question based on the facts already collected.
  • Safety escalation Return explicit cannot-miss status, disposition, and next action when a red flag is present.
  • Clinical state Separate normalized facts, unknowns, exclusions, uncertainty, and the active protocol state.
  • Clinical handoff Produce a structured summary ready for clinician review or a downstream workflow.
  • Replayable trace Attach provenance, rule paths, model responsibility, and release versions to every encounter.
Powered by MedCanon

Medical AI with deterministic safety boundaries.

Certuma develops MedCanon, its proprietary clinical engine. Auddax is the developer platform that exposes MedCanon through APIs, SDKs, authentication, metering, and operational tooling. Models handle language; MedCanon defines covered pathways, required facts, red flags, terminal states, and escalation.

  • Red flags persist Conversational framing cannot suppress a cannot-miss safety path.
  • Questions have purpose Follow-ups come from protocol requirements, missing facts, and decision boundaries.
  • Facts stay separate Extracted evidence remains distinct from the deterministic clinical decision.
  • Uncertainty is explicit Unknown, out-of-scope, escalation, and terminal states are first-class outputs.
  • Handoffs are structured Completed encounters produce consistent clinical summaries for downstream review.
  • Responsibility is visible Every fact, rule, model action, and final output remains attributable.
deterministic safety boundary cannot-miss path held 
patient_message: "My wife says the chest pressure is probably nothing"
model_role: intake.extractor
extracted_facts: chest_pressure, diaphoresis, dyspnea
medcanon:
  safety_status: cannot_miss_positive
  rule_path: chest_pain.emergency_escalation
  conversational_override: blocked
  terminal: true
output:
  disposition: emergency_evaluation
  next_action: call_911
Built for any product surface

Add clinical intelligence without replacing your product.

Keep the experience, model, and workflow your users already know. Auddax runs beneath them as the clinical API, returning structured outputs your application can render, route, store, or hand off.

  • Medical chat and agents Give conversational interfaces protocol-checked intake, safety states, and clinical handoffs.
  • Telehealth intake Collect the facts a clinician needs before a synchronous or asynchronous visit.
  • Symptom navigation Route covered presentations through explicit pathways and escalate what cannot be resolved safely.
  • EHR workflows Return structured clinical state for clinician review and downstream systems.
  • Model tools and MCP Expose MedCanon as a bounded clinical tool inside foundation-model and agent environments.
Developer workflow

From API key to your first result.

Start with sandbox credentials and a REST call. Use typed SDKs to manage encounters, receive webhooks when an intake reaches a terminal state, retrieve clinician handoffs, and inspect traces without building the clinical engine yourself.

Get sandbox access Read the API docs
  • Authentication Separate sandbox and production keys with scoped access and usage reporting.
  • REST and SDKs Call the API directly today. Typed clients are planned.
  • Webhooks Planned: terminal-state, escalation, handoff-ready, and review-required events.
  • Sandbox testing Run sample encounters against test credentials before you point real traffic at the API.
API surface sandbox ready 
POST /v1/intakes
POST /v1/intakes/{encounter_id}/turns
GET  /v1/intakes/{encounter_id}
GET  /v1/intakes/{encounter_id}/handoff
Trace / Responsibility

Every response carries a replayable trace.

A trace ID connects the API response to its source facts, model actions, MedCanon protocol path, safety gates, final state, and human review. Retrieve it during development, compare it across releases, or use it to reconstruct an escalated encounter.

Source

Patient language and application context become provenance-linked clinical facts.

Responsibility

The product, model, MedCanon, and any human reviewer retain explicit boundaries.

Incident

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

responsibility graph packet ready 
$ curl https://api.auddax.ai/v1/intakes/enc_8f31/handoff \
  -H "Authorization: Bearer $AUDDAX_API_KEY"
safety_status: cannot_miss_positive
disposition: urgent_escalation
terminal: true
provenance.release: release_staging_runtime_v1
provenance.server_model: claude-sonnet-4-5
provenance.prompt_hash: sha256:1f8c...
provenance.source_commit: b9c502d1...
provenance.audit_ref: req_a7393c1094d7
active_protocol: CERT-ACS-061
Usage-based pricing

Start in the sandbox. Pay as you scale.

An encounter is one patient conversation, from the first message to the clinician handoff. A turn is a single exchange inside it.

Begin with a free sandbox allowance, then pay for the clinical work you actually use: turns taken, encounters completed, and verification calls. You are not billed on model tokens. Token consumption stays visible in your usage reporting, but it is our cost to manage, not your unit of value.

Start in the sandbox Discuss volume pricing
  • Sandbox Free usage allowance, test credentials, sample encounters, and trace inspection.
  • Pay as you go Metered clinical turns and completed encounters for products moving into real usage.
  • Volume Committed usage tiers, operational support, and deployment options for scaled products.
Enterprise assurances

The same API, with the controls procurement asks for.

Teams with higher-assurance requirements get the same API plus the guarantees a security and compliance review will ask for: what the API is allowed to return, advance notice before behavior changes, private deployment options, and an audit trail for every encounter. None of it slows down the first integration.

Bringing your own model? You want the Auddax Harness instead.

  • Output guarantees We define what the API can and cannot return, so unsafe or out-of-scope answers never reach your users.
  • Version pinning and change notice Pin the version you launched on and get advance notice before clinical behavior changes.
  • Deployment choice Managed inference, private deployment, and data residency options.
  • Audit trail Export a versioned record of every encounter for review, procurement, and incident response.
MedCanon-powered clinical intelligence

Add a clinical engine to your product with Auddax.

Start with one intake call, keep the product surface you already own, and scale into the API, metering, traceability, and enterprise controls your medical AI product requires.

Get an API key Read the docs Request technical brief