High-fidelity synthetic data — certified at 95.69%.
Point Synthesize at your own CSV or Parquet. The flagship engine learns the joint distribution and emits faithful synthetic data — benchmark-certified at 95.69% fidelity under an independent QA harness.
One sealed-contract surface. Every run produces the same cryptographic evidence bundle, verifiable offline. Alternate engines (parametric, diffusion, relational, schema, hybrid) are on the roadmap under the same contract.
Whether the generated schema actually covers the concepts you asked for. PASS means every extracted concept is represented.
How readable, deterministic, and policy-clean the synthetic rows are after every post-render repair has run.
Cross-field invariants the engine evaluates against every generated row (arithmetic totals, derived numerics, enum coherence).
95.69% under an independent QA harness.
A canonical shared-split public benchmark (adult-income, mixed-type columns). The flagship at its default configuration reaches 95.69% overall QA on the held-out test partition. Per-column similarity, correlation and privacy metrics are emitted into the sealed utility report on every run.
Same seed across engines, single-host reproducible, under an independent QA pass. The schema engine is schema-only. Full dataset + split citation on /platform/evidence.
Flagship today. Alternates on the roadmap.
Each engine targets a distinct regime, all under the same sealed-contract interface and the same evidence bundle. The flagship ships today; the rest are roadmap — we'll say so plainly.
Flagship engine
Benchmark-certified at 95.69% under an independent QA harness — the default for production datasets.
- Heavy tails, rare categoricals and mixed-type joints, natively
- Aggregate-repair stage corrects marginal drift on roll-ups
- Deterministic: same seed + contract → same bytes
- Every artefact seals into the evidence chain
Parametric engine
Classical parametric path for sub-100-row datasets where a flow model would overfit.
- Per-column marginals with stable-tail handling
- Pairwise correlation structure reproduced
- No training step — closed-form fit in milliseconds
- Same sealed evidence bundle as the flagship
Diffusion engine
Score-based denoising diffusion for distributions where minority-class preservation matters most.
- Separate learned forward processes per column type
- Deterministic sampler under a sealed seed
- Strong on rare joint events others over-smooth
- Same contract + evidence bundle
Relational engine
Cross-table synthesis that preserves referential integrity across parent–child schemas.
- Foreign-key dependency order — parents first
- Per-edge cardinality reproduced from source
- Referential integrity 100% by construction
- Same contract interface as single-table
Schema engine
Schema-preserving fast path when you only need the shape, not the distribution.
- Same FK traversal as the relational engine
- Per-dtype priors — no per-table training
- Deterministic seed → same skeleton every time
- Same sealed evidence bundle
Hybrid cascade
Compose flagship, diffusion and relational engines under one sealed contract and one evidence bundle.
- One contract drives a multi-engine pipeline
- Cross-engine constraint passing (parent keys → child)
- Single aggregated quality report across the cascade
- One evidence bundle — the auditor sees one seal
One call. One contract. Verifiable output.
Hand the client a source, a sealed contract, a seed and an engine. It compiles the contract, runs the engine, emits the evidence bundle, and blocks until the quality gates pass or the fail-closed policy aborts.
- Deterministic: same contract + seed → byte-identical output
- Fail-closed: privacy risk over threshold → job aborts before emitting
- Offline-verifiable: the verifier CLI re-runs the chain locally
- Engine-agnostic API: swap engines with one string
from radmah_sdk import RadMah
client = RadMah(api_key=os.environ["RADMAH_API_KEY"])
# Flagship engine (default) — 95.69% benchmark-certified fidelity
job = client.synthesize(
source="s3://acme-prod/raw/customers_2026q1.parquet",
engine="flagship",
rows=1_000_000,
contract={
"pk": ["customer_id"],
"constraints": ["balance >= 0", "age BETWEEN 18 AND 120"],
"privacy": {"membership_risk_ceiling": "strict"},
},
seed=42, # sealed contract + seed = byte-identical re-run
)
job.wait() # blocks until quality gates pass or fail-closed
print(job.evidence.utility_report) # {'ks_median': 0.97, 'corr_frobenius': 0.02, ...}
# Verify the sealed evidence bundle offline — no network
client.verify(job.evidence.bundle_path)
# -> BundleVerified(seal=..., chain_ok=True) # file count varies by output shapeQuality metrics — emitted, not claimed.
Every synthetic dataset ships with quantitative fidelity and privacy measurements inside the evidence bundle. No subjective claims — the bundle proves the numbers and the verifier confirms the chain offline.
Distributional similarity
Per-column similarity between real and synthetic marginals on every run. The flagship is independently QA-certified at 95.69% on a reference benchmark; the full number set is written into the sealed utility report.
Correlation preservation
The pairwise correlation matrix is compared real vs synthetic. Every run passes the correlation gate and ships — or aborts fail-closed. Exact numbers land in the utility report.
Privacy risk metrics
Nearest-neighbour distance, membership-inference, attribute-inference and disclosure-risk metrics are measured and written into the privacy report. Zero PII by construction — synthetic rows are sampled, never copied.
Sealed evidence bundle
Every run emits the contract snapshot, reproducibility record, constraint/utility/privacy reports, run telemetry, artefact index and a chain seal. The verifier CLI replays the chain offline.
Audit-ready from day one.
Cryptographic evidence bundles, privacy-risk metrics and deterministic reproducibility give your compliance team what a DPIA, an ISO 27001 data-sharing control, or a SOC 2 audit needs to see. (RadMah states control alignment — it does not claim certifications it hasn't completed.)
Cryptographic evidence bundles
A signed, multi-artefact bundle covering the sealed contract, determinism proof, constraint/utility/privacy reports, run telemetry, evidence record and seal. Hashes chain every artefact; any change breaks the chain and the verifier refuses to certify.
GDPR Article 89 alignment
Synthetic data that doesn't relate to an identifiable person falls outside the material scope of GDPR Articles 5–15. The bundles document the process and full privacy-risk metrics, supporting Article 89 research-exemption claims and DPIA submissions.
Audit-ready provenance chain
Bundles provide the traceability, reproducibility and integrity verification auditors require. Every generation is deterministic — same contract + seed → byte-identical output — and the audit trail is cryptographically immutable.
Zero PII by construction
Records are sampled from the learned joint, never copied from source rows. Privacy reports measure disclosure and inference risk; when risk exceeds your configurable thresholds, the job fails-closed before emitting data.
Cross-border-transfer enabler
Synthetic output lets teams in different jurisdictions work on faithful data while source data stays in sovereign storage — removing the need for SCCs on the synthetic artefact.
Deterministic reproducibility
A sealed contract plus a seed produces byte-identical output on any host, any time. The reproducibility record captures the exact RNG state at every checkpoint.
Bring a CSV. Leave with an evidence bundle.
A 30-minute working session: upload (or we mock) a representative dataset, we run it through the flagship engine, and you keep the signed evidence bundle plus the utility report.
Mock Data
Deterministic schema-driven fabrication when statistical fidelity isn't the goal.
Autonomous Data Scientist
A 48-module agent orchestrates Synthesize across engines with approval gates.
Healthcare FHIR
HL7 FHIR R4 bundles with LOINC, RxNorm, ICD-10-CM.
Evidence chain
How every run is sealed end-to-end, and how you verify a bundle offline.