Time should be a primitive, not an afterthought
TNT is a temporal compute kernel: open infrastructure that makes time, causality, and consequence native to computing. The TNT Foundation is being established to maintain it, evolve it, and ensure it stays open.
Like relational databases made relationships native, TNT makes time native. History, replay, and provenance become system properties — not bolt-ons.
What TNT provides
TNT sits above storage and below applications. It is not a database, not a workflow engine, not a UI product. Storage remains your choice. TNT provides the temporal semantics and evidence layer above it.
Everything that happens in TNT happens in a task, with captured inputs, outputs, timing, and provenance. Nothing occurs without a trace. State is computed from event logs by deterministic reducers. For a given log and definition version, the result is always the same.
Point-in-time state
Bitemporality is native: event time versus recorded time, enabling "what was true then" versus "what was known then." No archaeological expeditions through logs.
Provenance and lineage
Every state change traces back through signals and payloads to source events. Lineage is a property of the system, not a separate tool bolted on after the fact.
Deterministic replay
Any historical execution path can be reproduced exactly. Seeded random generation can be captured and restored. Every sequence is verifiable.
Counterfactual branching
Fork reality at any point, modify parameters, replay to see what would have happened. Branch realities inherit from parent via sparse overlay. The audit record stays clean.
Ruleset versioning
All ruleset versions stay executable — points on the timeline, not archived artefacts. Replay under historical rules, not just current ones.
Decision tracing
Temporal provenance answers compliance questions directly. Prove what information was available at the moment a decision was made.
Three-layer architecture
TNT separates concerns into three layers. The kernel provides temporal primitives. The core provides reusable domain components. Applications are primarily configuration, not code.
Configuration-first
Applications are expressed primarily through TOML configuration, wiring together core components. Custom logic is added via adapters when the standard components don't cover the domain. Non-programmers can create functionality through presets.
Reusable components
Adapters, dataclasses, Studios, Channels. Domain-specific but not application-specific. A financial adapter built for one application works in any financial context. Patterns extracted from real use become the library.
Temporal primitives
Time, ordering, point-in-time state, reality branching, consequence tracking. The kernel handles routing, caching, and coordination internally. No microservices sprawl. Runs on a single server with SQLite in development, PostgreSQL in production.
Why a foundation
Infrastructure this fundamental shouldn't be owned by a company that can be acquired, that might raise prices, or that could change terms when it becomes convenient. The TNT Foundation is being established to make structural guarantees, not just promises.
These are the principles the Foundation is being built around. The goal is constraints that bind future leadership, not just current good intentions — so that building on TNT means depending on a non-profit with a narrow mission, not a commercial vendor's roadmap.
Narrow mission lock
"Maintain and evolve open temporal computing infrastructure." No mission-adjacent expansion. Change requires 75% trustee supermajority plus 12-month notice. The Foundation does one thing.
Independent trustees
5–7 trustees, no single entity appoints a majority. Term limits: 4 years, maximum 2 consecutive. At least 2 trustees independent of TNT Research and major licensees.
Pricing constraints
License fees sustain operations, not maximise revenue. Annual increases capped at inflation + 10%. Published schedule, equal terms for all licensees. No secret deals.
Compensation caps
Trustee compensation capped and publicly disclosed. No Mozilla-style extraction where leadership compensation dwarfs the mission.
No capture
No exclusive licensing arrangements. No controlling stake in any for-profit entity. Commercial relationship with TNT Research capped at 25% shareholding. Related-party transactions require independent approval.
Full transparency
Annual public financial statements. Annual community meeting. Public roadmap with community input. Architectural decisions documented with rationale.
The ultimate backstop: the fork
Once released under AGPL, the license will be irrevocable. A hostile Foundation could be routed around. The community could fork, the code would remain free, and the Foundation would become irrelevant. This is the nuclear option that makes all other constraints credible. A Foundation that fears forking will not become extractive, because extraction triggers the fork.
Planned structure
TNT will separate infrastructure stewardship from commercial activity. The Foundation maintains the technology. TNT Research builds on it and serves clients. They'll be connected but neither will be able to capture the other.
TNT Foundation
Will own and maintain kernel and core layer IP. Independent governance with structural constraints. Revenue from commercial license fees, certification, and training accreditation.
Will hold a minority stake in TNT Research — enough to benefit from commercial success, not enough to depend on it.
TNT Research Limited
Provides temporal forensics, consulting, managed hosting, and enterprise support. Currently holds all IP; will license from the Foundation once established.
Revenue from expertise, not IP lock-in. When the Foundation is operational, dividends will flow partly back as shareholder returns.
How TNT came to be
Years ago I designed something called AgentWise, an AI-heavy system for real estate operations that quietly required an awkward foundation: temporal data as a first-class concern, structured state that AI could act on, consequence tracking, counterfactuals. The architecture was right, but the world wasn't ready. I was looking at Druid for the temporal layer, and AI wasn't anywhere near capable enough. The idea went into a drawer.
Then in early 2025 I left American Express after fourteen months building highly concurrent financial systems. In April a friend asked me to improve a simple HR chatbot: standard RAG, embeddings, a vector store, Slack. He had a short list of improvements.
It was a rabbit hole.
Once you stop treating HR questions as isolated text queries and treat them as questions about an organisation, you hit knowledge hierarchies immediately. The answer depends on who's asking, so one set of embeddings breaks. You end up modelling entities, relationships, time, versioning, boundaries. Every fix reveals the next problem you were previously ignoring.
Somewhere in that mental maze, things I'd done running DetectRight — a device detection system that competed globally for over a decade — suddenly became useful, and the old AgentWise ideas snapped back into place. The tooling finally exists to build the substrate rather than just talk about it. Real estate was never the point.
I used LLMs heavily while building TNT; it wouldn't exist without them because once code was essentially disposable I could follow ideas quickly, look for the loose end in the type checker that pointed the way to the next strand, and follow ideas to their conclusion. The main difficulty was that TNT inverts an awful lot of concepts, and Claude would try to turn them right way up again. But once it was reminded of The TNT Way it was able to cope admirably.
It's tens of thousands of lines of kernel and tests, mostly unsexy infrastructure but hung together in a pretty elegant and useful way. The interesting stuff is going to come from what gets built on it.
Chris Abbott — Founding Chairman
Background in enterprise finance (American Express), production distributed systems (DetectRight), signal processing and audio engineering (five published books), and a Psychology and Statistics degree. The cross-domain pattern recognition that produces temporal computing comes from spending decades in fields that care about causality, provenance, and consequence from different angles.
Path to open source
TNT will be released under AGPL v3, with dual-licensing available from the Foundation for proprietary use. The path there is phased, because releasing infrastructure before the architecture is proven does more harm than good.
Proprietary development
TNT Research controls all IP while iterating rapidly. APIs can break freely. Canonical patterns are established through reference implementations. The Foundation governance structure is being established in parallel.
Source-available
Select partners can inspect and deploy the code under agreement with the Foundation. Feedback from real self-hosters before full release. Controlled expansion to test the support model.
AGPL open source
Kernel and core released under AGPL v3. Modifications must be shared if running as a service — protection against cloud provider capture without compromising true open source. The fork threat becomes the real enforcement mechanism.
Get in touch
For questions about the Foundation, the technology, licensing, or partnership opportunities.
chris@tntresearch.co.uk