Licensing
The Fluxtion runtime and builder API are open source — they let you author graphs and run generated processors. The local builder and cloud service generate processors at design time and are licensed separately for evaluation and commercial use.
That generation step is the patented flow — and its output is the deterministic, auditable artifact your compliance team reviews. The generator is needed to produce that artifact; once produced, it runs forever on the open runtime.
The architecture, end to end
The builder generates at design time; the open runtime carries it to production — embedded, standalone, edge/WASM, or hosted — with no cloud and no key past sign-off.
The generation step touches your process when you create or change it. Everything to the right of "Generate" is runtime-open or yours.
Your code · open
Describe the event logic in Java — the DSL, Spring XML, or imperative nodes. Plain source you own and version. Nothing leaves your machine yet.
Local builder or cloud
The local builder or cloud service runs the patented graph-inference flow to generate your processor — the optimised, reflection-free dispatcher. This is the commercial generation step.
Yours to review
The output is deterministic generated source, the graph (GraphML), and replayable audit — human-readable and reproducible. This is the artifact your compliance team reviews and signs off.
Open source
The open-source runtime executes the signed-off processor — JVM, native image, or WebAssembly — deterministically, emitting the same audit trail. No cloud, no key, no dependency on us.
The builder/cloud service is used to generate or change a business process — not to run one that's already signed off. If the service were unavailable tomorrow, every signed-off processor keeps running, unchanged, on the open runtime.
What's open · what's paid
Everything you run and the generated processor source you ship are open or yours. The separately licensed part is generation — creating or changing the processor artifact through the local builder or hosted cloud service.
No production lock-in: the generated processor source belongs to your project — inspect it, commit it, audit it, deploy it, and run it with no ongoing Fluxtion cloud access.
Executes your generated processor and emits the audit trail. One jar, no reflection on the hot path. Open source under AGPL today; a move to Apache 2.0 (for friction-free embedding) is under consideration.
The local graph-inference / generation engine. Free for internal evaluation and proof-of-concept use; production or commercial use requires a written commercial licence.
The generation engine hosted and run for you, reached with an API key. Telamin’s hosted commercial generation path.
The deterministic, human-readable source the builder produces — the artifact you audit, sign off, and ship. Yours.
Host glue that lets the generated processor run in the browser / on the edge as WebAssembly. Already shipped under Apache 2.0.
Visual graph + audit step-through in the IDE. Licensing is being finalised ahead of public release.
The rest of the toolchain: the project starter and playground are free and keyless; cloud generation needs an API key. Mongoose and its plugins are a separately-licensed production-hosting and connector tier — Fluxtion processors run embedded without Mongoose, or hosted inside it for server management, agent threads, an admin UI, and enterprise connectors.
The runtime is open source — AGPL today, with a move to Apache 2.0 (for friction-free embedding in any application) under consideration. Either way, what you deploy and the generated source you sign off are yours, and run on the open runtime.
The local builder is available for internal evaluation, testing, and proof-of-concept use. Production or commercial use of the generation engine requires a written commercial licence. That protects the generation step; it doesn't limit what you build with the processors it generates.
The generated processor source is your application artifact. Generated processors and runtime use are separate from the builder's evaluation/commercial licence.
Why it holds up to audit
Regulated processes are signed off on artifacts, not promises. And the generator emits more than code: alongside the deterministic, human-readable Java source it produces the supporting documents an audit relies on — a graph of how every event flows, a replayable audit trail, and the model behind both. A reviewer can read the logic, re-run a recorded event stream, and get the same result every time — the property an auditor actually needs.
And the outputs are customisable to your requirements: the set of generated documents — formats, fields, the audit and graph artifacts — can be shaped to match your organisation's compliance and sign-off process, rather than forcing you onto a fixed template.
Because the artifact is self-contained and the runtime is open, sign-off is durable: the processor you approved is the processor that runs in production, with no hidden runtime service deciding behaviour. You change it only by generating a new version — which goes through the same review.
Same input, same output — every run, on JVM, native, or WASM.
Record an event stream, replay it through the same dispatcher, reproduce any decision.
Plain generated source + graph — no black box to take on trust.
Define → generate → auditable artifact is the patented graph-inference mechanism (US filing 2026): turning a declared graph into an optimised, reflection-free, deterministic dispatcher. The open-source runtime carries a patent grant for its use, and processors generated through the Fluxtion service are intended to run freely on it.
Go deeper
Why accountable, replayable logic is the unlock for agentic AI in regulated processes.
ReadHow the closed-world generator turns a declared graph into the deterministic dispatcher.
ReadThe runtime, the DSL, audit + replay, and AOT generation — the full reference.
Open docsThe browser playground generates and runs processors with no key and no install. When you're ready to ship, the project starter shows exactly when the cloud is needed — once, at build time.