Understand the approach.
Decide where it fits.

Telamin connects AI-assisted application design, compiled execution and evidence-based investigation. Your assistant helps assemble reusable components and application logic. Fluxtion generates the coordination between them as specialised software your team can review and test.

Once built, the application runs without an LLM coordinating each event. The Analyser helps your team investigate its recorded behaviour.

AI helps build it. Compiled code executes it. Evidence helps you understand it.

How Telamin works

AI is useful for interpretation, exploration and probabilistic reasoning. Repeatedly asking a model to coordinate a predictable process also adds inference cost, latency and variability.

Fluxtion compiles that repeatable coordination into software. Routine events use your computing infrastructure without another authoring-model request. Model calls remain an option where the application actually needs them.

Scale the workflow, not the model bill.

Understanding runtime costs

Give the assistant less unnecessary code to write. It can select components and implement business behaviour while Fluxtion derives event routing and dependency coordination. Reusing libraries reduces the need to recreate trusted functionality.

This can reduce generated code, token use, debugging and maintenance. Savings depend on the task, model and components. Our integration experiment demonstrates one controlled workload; it is not a general savings guarantee.

Read the AI-assisted integration experiment

Yes. A component can call an LLM, machine-learning model or external decision service. Compiled logic can validate the response, apply limits and route the result.

The model output remains probabilistic. Investigation or replay needs the relevant inputs and outputs to be captured. Probabilistic reasoning can participate in a system with deterministic coordination.

Determinism explained

A published ten-node Java fixture measured generated dispatch at 8.44 ns/event, versus 7.12 ns/event for hand-written dispatch with the same coordination semantics: a difference of 1.32 ns. It observed zero steady-state per-event allocation in that fixture.

This measures dispatch, not end-to-end application latency. Components, integrations, audit settings and hardware affect real results. Low coordination overhead leaves more of your computing budget for useful application work.

Benchmark, methodology and limitations

Fluxtion generates specialised event processors. Mongoose optionally hosts them and connects feeds, services and outputs. The Fluxtion Audit Log Analyser investigates recorded behaviour and exports evidence bundles.

Hosted generation delivers Fluxtion generation as a managed service. These are connected parts of one workflow: compile, operate and investigate.

Products and availability

Yes. Supported Java components, internal business logic and new components can participate in the same application. Fluxtion derives their coordination from their declared relationships and integration contracts.

Reuse engineering you already trust, and author the behaviour that is specific to your business. Some libraries need adapters or additional integration work. Configured audit records help show how the integrated components participated in an event.

Reusable integration

No. A wrong business rule can consistently produce a wrong answer. Fluxtion makes coordination explicit: events and conditions activate paths through compiled code.

Reproduction requires the same application version, starting state, event order and relevant external inputs. Clock reads, randomness, live services and concurrent state must be controlled or captured. Predictable coordination makes behaviour easier to test and investigate; your requirements and rules still need validation.

See a worked order-check example

Java is the primary authoring language and generated-source target. Processors can run on the JVM or be packaged as GraalVM native executables. The Playground runs Java in the browser using CheerpJ.

A separate TeaVM/WASM-GC path has a developer-run build and browser demonstration; hosted builds and broader deployment support remain in development. C++ generation is in pilot preview, without equivalent audit logging and Analyser support.

Deployment capabilities and status

Normal event processing needs no hosted compiler connection once a processor has been generated ahead of time and built. Embed it in your Java application or host it with Mongoose, in your own environment.

Hosted generation receives a graph model and returns generated source during the build process. New generation requests and interpreted development modes are separate from running an already-built application.

Deployment and data flows

Hosted generation does not require your whole source repository. It does receive a structured graph model, including component identities, relationships and configured field values. Those values are unredacted within the HTTPS request and may be commercially sensitive.

Supply secrets at runtime rather than embedding them in the generation model. Your built application runs in your environment. Private generation is in development; review the current data flows, retention and licensing arrangements before adoption.

Confidentiality and data flows

Fluxtion can generate audit instrumentation alongside execution code. Depending on configuration, records capture triggering events, component activity and selected values. The Analyser relates these facts to the execution graph and relevant source.

The evidence establishes what was captured. Its strength depends on coverage and completeness; it does not automatically establish every external effect or prove the requirements were correct.

Evidence and investigation

An evidence bundle is a portable investigation, created by the Analyser under the direction of a person and their LLM. They choose what to investigate, inspect the recorded facts and save the steps that explain the result.

The Analyser packages selected runtime records, the application graph and saved investigation material into a bundle another person can reopen. It is a saved snapshot of the captured context, so producers and recipients can examine the same material. The LLM helps explain the evidence; it does not replace the underlying records.

Use the bundle to continue an investigation, an HTML reel to follow the saved walkthrough in a browser, or a PDF to share a readable report. Include the evidence needed by the recipient, and review it for sensitive information before sharing.

Who creates a bundle, and who can use it?

Yes, with the necessary inputs, state and compatible application build. A developer and their connected assistant can follow recorded dependencies and values, propose a targeted change, obtain human approval and test the corrected application.

The Analyser exports investigations as .fexp bundles. It does not execute the processor: replay inputs run separately against the appropriate build. Compare the resulting records and share the evidence for the correction.

Follow an investigation

Controlled execution, configurable logging, investigation and human review can support an organisation’s evidence needs. Whether the EU AI Act applies depends on the system and its intended use.

The European Commission’s current guidance describes documentation, logging, oversight and risk-management obligations for applicable high-risk systems. It lists 2 December 2027 for Annex III high-risk uses and 2 August 2028 for high-risk systems embedded in Annex I regulated products.

Telamin provides technical capabilities; it does not certify safety or automatically make an application compliant. Check the official guidance for your use case and the current timetable.

See how evidence bundles support investigation and human review, within their stated capture limits.

European Commission guidance and timeline

Yes. Fluxtion has paid production use in electronic market making, across pricing, hedging, order processing, risk management and credit control.

This is a demanding real-world deployment. Telamin is now broadening adoption through focused pilots and design-partner engagements.

Production background and technical evidence

Fluxtion’s technology has a granted US patent, US 11,074,079 B2, relating to generated event-handling instructions. The compiler derives execution coordination from application structure.

The patent is part of Telamin’s intellectual property; it does not imply protection for every current or proposed product feature.

Read the granted patent

Pre-generated Playground examples run without an account. The published introductory account allowance is 250 hosted generations and 500 interpreted runs, with a 20-node graph limit and other Free-plan limits. This is a one-time early-access allowance and may change.

Self-service purchase of additional credits is not yet open; there is no published standard paid-credit rate. Team access, higher allowances, production licensing and support are agreed commercially during the pilot stage.

Current allowances and commercial options

Generator access, runtime software, generated code, commercial components, redistribution and support have distinct rights.

An ahead-of-time-built processor does not technically switch off when generation entitlement ends: it does not call the compiler per event. The contractual right to keep using or distributing it is a separate matter, agreed in your licence.

Licensing explained

A funded pilot is a paid customer engagement to evaluate a specific technical and commercial benefit. We agree the workflow, scope, cost, integration requirements and measurable acceptance criteria before starting.

Telamin can build alongside your engineers or teach your team to author the application. Deliverables can include a working implementation, tests, measurements and investigation evidence. At the end, assess the results and decide whether to adopt, extend or stop.

How pilots work