How it works

A digital twin of your revenue cycle, with AI only at the edges

VORTEX keeps a live, full-fidelity copy of your claims, remittance, billing and contract data, spread across many small instances on commodity hardware. Fractal Apps do the work on that copy. A language model writes the Apps and explains their results, and never reads the records themselves.

The architecture

A revenue cycle analyst asks a question. The language model writes a Fractal App, which the Fractal mesh runs in parallel against its local copy of your financial data. The results go back to the model, which summarizes them for the analyst.

VORTEX: a healthcare revenue cycle application with Fractal as the computing and storage layerAn analyst tells an AI language model what they want. The model writes a Fractal App, which is deployed to the Fractal Computing mesh and runs in parallel on every Fractal instance. Results return to the model, which summarizes them for the analyst. The EHR, billing, claims, remittance and contract systems feed the mesh by one-way sync, forming a digital twin.AnalystCFO · revenue cycleAI Language ModelCaptures the questionWrites the Fractal AppSummarizes the resultsNEVER SEES PHIQUESTIONANSWERFractal AppSmall, bounded programfor one data shardResultsVariances and totals,not patient recordsDEPLOYRESULTS123456Fractal Computing meshThe App runs on every instance, in parallelEach instance: own data shard+ full stack · peer-to-peerYour systems of recordEHR · billing · claims · remits · contractsONE-WAY SYNC→ DIGITAL TWINAI: beginning and end of the workflowFew tokens · question in, summary outOnly code and resultscross between layersVariance reportdeliveredAppΣSummary
Step 1 of 6
  1. 1The analyst asks a question in plain language. For example: "Which payers paid us below contract last quarter, on which codes, and by how much?"
  2. 2The language model writes a Fractal App. The App is a small program that works on one data shard, inside a bounded context.
  3. 3The App is sent to the Fractal Computing mesh and deployed to every Fractal instance.
  4. 4Every instance runs the App in parallel against its own shard of the claims twin. The results are aggregated.
  5. 5The results go back to the language model: variances, totals and exceptions, not the underlying claims or patient records.
  6. 6The model summarizes the result as a variance report the team can act on and take to the payer.

AI at the beginning and end of the workflow, and nowhere near PHI

Language models are good at two things this needs: understanding loosely stated questions, and explaining structured results in plain language. Fractal uses them for exactly those two steps.

At the beginning: capturing the question

  • No query language, schema or report menu. The analyst describes what they want to know.
  • The model maps the question onto your claims, remittance and contract data structures and writes a Fractal App.
  • A new question doesn't need a new development project. The model writes a new Fractal App.

At the end: a report people can act on

  • The App returns structured results: variances by payer and code, denial patterns, exceptions, forecasts.
  • The model turns them into a summary: what was found, what it is worth, and what to pursue first.
  • Every figure in the summary traces back to the computation, and the claim lines, that produced it.

The model never touches the data. It sees the question, the App it wrote and the App's results. It does not read patient or claims records, it never has credentials to your systems, and because it reads so little, AI token costs become immaterial.

The digital twin: the work happens on a copy, never on production

All of the actual work, storing the data, processing it and producing results, happens in the Fractal mesh, on a twin of your systems of record.

A live, full-fidelity twin

Data from your EHR, billing, claims, remittance and contract systems is replicated continuously into the Fractal instances. Not a backup, a snapshot or a stale staging copy.

One-way sync

Data flows from your systems to the twin only. There is no reverse path, so nothing an App does can reach a system of record that way.

Production cannot be corrupted

Hallucinations, prompt injection, cascading agent errors and model drift are contained in the twin. Fractal reports zero source-system corruption events across its production deployments.

Human-approved promotion

When a result should change a system of record, such as a corrected claim or an appeal, it goes back only through an explicit, logged, human-approved step outside the AI loop.

Distributed, not concentrated

Each instance holds a discrete shard of the twin in its own multi-model database. A breach of one instance exposes a partial fragment, not the whole system.

Your QA environment

Every new App, configuration change or feature is validated on the twin, against real data, before anything reaches production.

What the VORTEX Apps check

The VORTEX Apps, with your payer logic and contract library, run continuously against every transaction in the twin.

Recover

Underpayment detection

Expected payment, from your contract terms, against actual payment, on every claim line.

Prevent

Denial pattern analysis

Recurring denials by payer, code and contract, found as they recur.

Enforce

Contract variance

Where payer adjudication logic has drifted from what was agreed.

Protect

Fraud and anomaly detection

Unusual billing, payment and remittance patterns across the whole claims history.

Plan

Forecasting and modeling

Cash, payer mix and contract scenarios, run on all of your data in minutes.

Resilience: a hot backup that is always running

Because the twin stays in sync with production, it isn't a cold backup you hope works. It is a live, continuously validated parallel operation.

When a primary system or vendor fails, today
Revenue stops
  • Ransomware halts clinical and financial operations together
  • A clearinghouse outage stops claims across the sector
  • Recovery from cold backups takes days to weeks
With the VORTEX twin
< 30 sec a year
  • The twin keeps processing while the primary system recovers
  • Failover at about one-tenth the cost of the systems it protects
  • Data sharded across instances, so no single point of failure

Downtime is Deployment Measured.

Deterministic AI: answers you can audit

Once written, a Fractal App is ordinary code. The same question over the same data gives the same answer every time, and every number can be traced and audited, like any other enterprise software. That matters when a variance report becomes an appeal, a payer negotiation or an audit finding.

Detail Scale invariance and Deterministic AI, on fractal-computing.com →

Built on Fractal Computing

VORTEX is built on Fractal Computing, a production-proven platform that distills the enterprise software stack to its essential core, then optimizes it with Locality Optimization™: data and computation sit together on each instance, so software stops waiting on I/O.

≥ 10×
faster; up to 1,000,000× measured
≥ 50%
lower cost than the application it replaces
Daily
new feature delivery

Deployment Measured, in Fortune 500 production deployments in utilities, telecommunications and financial services.

More The full architecture → Benchmarks →

Know what you are leaving on the table

The retrospective revenue analysis is free. It uses your own claims data, measured against your own payer contracts, with no change to your production systems and no commitment to start.