Language models are good at understanding what people want and at explaining results. They are slow, costly and non-deterministic when asked to process an enterprise's data. In Fractal's architecture the model does only the first and last steps. Fractal does the heavy lifting in between: it stores a digital twin of the systems of record and runs the work in parallel across many small instances on commodity hardware.
Most Enterprise AI designs put the language model in the middle of the work. The model reads the data, reasons over it and writes the results. That is expensive, because every record becomes tokens. It is slow, because the model sits on top of the conventional database stack. It is also risky, because a non-deterministic model with write access to production can corrupt millions of records at once.
Fractal changes where the model sits. AI is used only at the beginning and the end of the workflow. At the beginning, the model turns the user's request into a Fractal App: a small, bounded program. At the end, it turns the App's results into an executive summary. Fractal is the distributed computing and storage layer in between. It holds a continuously synchronized digital twin of the systems of record, runs the App in parallel on every Fractal instance, and returns the results.
The outcome is AI with the flexibility of a language model and the deterministic behavior of enterprise software. The systems of record cannot be corrupted, performance improves by orders of magnitude on inexpensive hardware, and language-model token costs become immaterial.
Executive brief The decision, in business terms →
The user talks to the AI language model. The model writes a Fractal App, which the Fractal mesh runs in parallel against its local copy of the enterprise's data. The results go back to the model, which summarizes them for the user.
Executive brief What a Fractal deployment gives you →
Language models are good at two things this architecture needs: understanding loosely stated requests, and explaining structured results in plain language. Fractal uses them for exactly those two steps and nothing else.
The model never touches the data directly. It sees the user's request, the App it wrote, and the App's results. It does not read millions of records, and it never has credentials to the systems of record.
Executive brief Your data stays yours →
All of the application's actual work, including storing the data, processing it and producing results, happens in the Fractal Computing mesh. The mesh works on a digital twin of the systems of record, never on the systems of record themselves.
Fractal replicates data from the systems of record into the Fractal instances. The twin is a continuously synchronized, full-fidelity replica, not a backup, snapshot or stale staging copy.
Data flows from source to twin only. There is no return path through the sync channel, so nothing an App does can reach a system of record that way.
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.
When a result should change a system of record, it goes back only through an explicit, logged, human-approved promotion step that sits outside the AI loop.
Each Fractal instance holds a discrete shard of the twin in its own multi-model database (relational, document, time-series, graph, vector). The data is spread across the mesh, not concentrated in one database server.
A MapReduce-style middleware runs the App on all instances at once and combines their results. Instances coordinate peer-to-peer over HTTPS, with no central broker and no single point of failure.
Executive brief AI without risk to your systems → Hot backup at a tenth of the cost →
Fractal's architecture is scale invariant. Every Fractal instance is the same small, self-contained stack: application code, middleware, web server, shard and partition manager, database scheme library, multi-model database and stream processor. Scale comes only from the number of instances, from one on a smartphone to 1,000+ on a large server. An App written for one instance runs unchanged on all of them.
The building block is the Fractal: a small, self-contained, vertically integrated software stack that runs as an independent processing unit in a loosely coupled distributed system. It keeps only the essential 0.1% of the conventional enterprise software ecosystem. Each instance carries a complete copy of the application logic, so it runs autonomously. Instances talk to each other over a peer-to-peer HTTPS mesh with no central coordinator and no shared-memory bottleneck.
| Layer | Function | Role when AI writes the App |
|---|---|---|
| Application Code | Small, focused modules that use context libraries for domain-specific heavy lifting | Where the AI-written App plugs in. The App is a thin module, not a whole application. |
| GUI Widgets | Front-end interface components | Ready-made components for showing results in the Enterprise Application |
| Distributed Processing Middleware | MapReduce variant for parallel computation across Fractal instances | Runs the App on every instance at once and combines the results |
| Web Server | HTTPS peer-to-peer communication between Fractals | Instances coordinate without a central broker |
| Shard & Partition Manager | Granular, explicit, developer-controlled data distribution | Each instance gets its own shard, so the App never has to fetch remote data |
| Database Scheme Library | Domain-specific context, stored procedures and co-located application logic | Business knowledge (rates, billing logic, account hierarchies) the App calls instead of rebuilding |
| Multi-model Database Engine | Relational, document, time-series, graph and vector data in one engine | The App queries every kind of data in one place, with no cross-system joins |
| Memory Manager / Stream Processor | Pipelined data movement from persistent storage to CPU registers | Data is cache-resident before the App needs it, so the App never waits on I/O |
The whole stack is written in JavaScript and is identical on every platform, so an App is written once and deployed anywhere. Typical instance counts are 1 on a smartphone, 1–10 on a tablet, 10–20 on a desktop PC, 100–400 on a small server such as a Mac mini or Intel NUC clone, and 1,000+ on a large server.
Deterministic AI: the flexibility of a language model for capturing intent, combined with the repeatable, auditable behavior of enterprise software for doing the work.
Executive brief AI you can rely on → Runs where you need it →
Conventional enterprise software spends most of its time waiting on I/O. Each abstraction boundary (application, ORM, connection pool, network stack, database server, storage engine, disk) adds roughly 10 I/O wait states per useful instruction cycle. With seven boundaries, software runs about 107 below what the hardware can do. Fractal's Locality Optimization™ removes that waste.
Figures are Fractal-reported results from Fortune 500 production deployments in utilities, telecommunications and financial services.
Executive brief ≥ 50% lower cost, ≥ 10× faster →
When a language model processes enterprise data itself, token usage grows with the amount of data: every record the model reads costs tokens. In Fractal's architecture the model handles only the request, the App and the results. Token usage then depends on how complex the question is, not on how much data is behind it.
| Step | Model at the center of the work | Fractal architecture |
|---|---|---|
| Capture intent | A short request | A short request |
| Do the work | The model reads and reasons over the records, repeatedly. Token use grows with every record and every rerun. | The model writes one Fractal App, typically a few hundred lines. Fractal runs it over all the records at no token cost. |
| Present results | Summary from whatever fit in the context window | Summary from compact, aggregated App results |
| Repeat next month | The full cost again | Rerun the same App: no new tokens until the summary step |
| Scaling to more data | Token cost scales with data volume | Token cost stays flat; Fractal adds instances |
Order of magnitude: the reference billing deployment holds 3.6 trillion input records. Even at a few tokens per record, reading that data would cost trillions of tokens. Writing an App and summarizing its results takes thousands. The language model becomes a small, fixed cost per question, and the data processing runs on about $20K of hardware.
Executive brief AI token costs become immaterial →
Fractal deployments start with a 90-day proof of concept that runs alongside existing systems. The systems of record keep running unchanged. The Fractal twin and the AI layer are built in parallel and measured against live production data.
Executive brief A safe, controlled migration path → Recommended next step →