Proof of when · peer‑to‑peer · no middleman
Prove when it happened.
To anyone. Without
trusting anyone.
LOTI weaves every digital event into a shared fabric of time — so you can prove, mathematically, both when a document, photo, message, or measurement existed, to within a narrow window, and which of two events came first. It's not just timestamping — it's a provable ordering of events, too.
The problem
A digital timestamp is just a number. And numbers can be changed.
When the timing truly matters — who invented it first, whether the contract was signed by the deadline, when the footage was really shot — we fall back on trusting someone: a platform, a server, a notary, a screenshot. Every one of those is a single point of trust, failure, and dispute.
Timestamps are editable
The "date created" on a file, an email header, a post — all of them can be set to anything. Proof needs more than a claim.
Authorities can fail
A central timestamping service can go dark, be hacked, be pressured, or simply be disbelieved by the other side. Trust is a liability.
Blockchains overshoot
They can timestamp — but they're public, slow, and cost a fee every time. Overkill for something that should be quiet and free.
The idea
A clock nobody owns.
Instead of one clock everyone must trust, LOTI lets everyone keep time together. Nodes across the network keep a steady heartbeat and constantly nod to their neighbors — weaving a tamper-evident fabric of "this came before that."
To prove when your event happened, LOTI finds the two heartbeats that bracket it. To fake it, you'd have to unravel the whole fabric — and the mathematics simply won't allow it. You can't forge the past, and you can't pre-compute the future.
There's no global vote and no winner. Everyone is free to form their own view of the timeline — but nobody can ever prove a contradiction. It's agreement where it counts, freedom everywhere else.
Two proofs from one fabric. LOTI is a timestamping network — and the same fabric also proves which event came before which, a tamper-proof happened-before ordering. Often you don't even need a clock for that: two events can be conclusively ranked against each other even when neither carries a trusted timestamp. Attach a reference clock and the ordering reads out as a date; leave it off and the order still holds. Provable time and provable order, from a single record.
Anatomy of a proof
A chain that begins and ends at your own clock.
A proof is a chain. It sets out from the clock you trust, threads through the steady heartbeats of nodes across the network, reaches the event in question, and comes all the way back — pinning it between one tick that came provably before and one that came provably after.
Each heartbeat carries a signed nod to the neighbors it just heard from. Follow those nods outward from your event and, hop after hop, they lead back to a clock you chose to measure against — your own, a lab's, a notary's. The two bracketing ticks are your time bounds; the reference clock at each end is what turns them into a date you can read. Nothing in the chain is asserted after the fact — it's the record of nods that actually happened, in the order they happened, which is exactly why it can't be re-told two ways.
You can't forge the past
The moment a heartbeat is woven in, your neighbors have echoed it and stacked their own ticks on top. To move a past event you'd have to rewrite every link that followed — on every machine that already holds a copy. The fabric has set, and the math rejects any chain whose links don't line up.
You can't pre-compute the future
Say you fake a protest — photos and video generated by AI weeks ahead — then publish them on the day so they look live. To hold up, your event has to agree with everything else the network recorded at that instant: the ledger acts like an oracle for reality. Did the weather station's proven readings match your footage? A camera down the street? Depending on precision, even a traffic light's timing can contradict your video. You can't prepare the present in advance — you'd have to forge it exactly as it unfolds, which is far harder.
How you use it
Four steps, and no leap of faith at the end.
Join the network
Run a node, or rely on one run by someone you trust — your company, a lab, a city, a law firm, a public notary.
Stamp your moment
Point LOTI at any file or sensor reading. It's woven into the fabric of time instantly — and for free.
Ask for proof
Request "when did this happen?" or "which came first?" LOTI hands you a small, portable proof file.
Anyone verifies
They check the proof themselves — offline, in seconds. No account, no network, no trusting you. It holds up, or it doesn't.
Use cases
Wherever "when" and "who was first" carry consequences.
Legal disputes
Settle "when" and "who was first" with mathematics, not memory. Prove a notice, filing, or agreement existed before a deadline.
Document timestamping
Notarize any file — a manuscript, a design, a will — so its existence by a date is provable forever, without a notary's fee.
Copyright & priority
Establish that you made a song, photo, dataset, or invention first. Portable prior-art you can show any court or client.
Oracle for physical reality
Sensors stamp their readings; independent sensors corroborate each other. A trustless bridge between what happened in the world and what you can prove — noise, seismic, or camera data lining up with a real event.
Provenance vs. deepfakes
Prove footage existed before — or couldn't have existed before — the event it claims to show. Time becomes part of authenticity.
Research integrity
Prove when data was collected or a result reached. No backdating, no quiet revisions — a defensible record of scientific priority.
Why it's different
The strengths come from what LOTI refuses to do.
Trustless
Proofs are checked with math, not middlemen.
Permissionless
Anyone can join. No gatekeeper, no application.
Private by default
Only fingerprints travel the network — your content stays with you.
Practically free
No coins, no mining, no gas. Publishing costs nothing.
Portable proofs
A single file, verifiable offline, for as long as it matters.
No single point of failure
Decentralized and censorship-resistant by construction.
Compare
Between a notary and a blockchain — the sweet spot.
| LOTI | Timestamp authority | Blockchain | |
|---|---|---|---|
| Who you trust | A reference you choose — or the math | The authority | The chain & its validators |
| Proves order? | Yes — a native happened-before ordering, clock or no clock | No — stamps each event alone | Not within a block — same-block events share one stamp (≈10 min, Bitcoin) |
| Time resolution | Tunable — sub-second if you push the clock and topology | The authority's clock | Capped by block time — seconds to minutes |
| Cost per proof | Effectively free | Per-stamp fees | Transaction / gas fees |
| Your content | Stays private | Shared with the authority | Public forever |
| Resilience | No single point of failure | Central | Robust, but heavy |
| Permission | Open to anyone | Gatekept | Open |
| Footprint | A light background service | — | Energy / capital intensive |
The honest ledger
What it costs, and what you get.
LOTI is a network — it grows stronger with every participant. Here's the trade, without the sales gloss.
What it takes
- A node needs a bit of bandwidth and a slice of storage — capped at a budget you pick and flat forever, so it never outgrows its disk. Like a modest background service.
- Hardware is cheap: a node runs always-on, low-power, on a ~$15 Raspberry Pi Zero — its memory stays bounded and its clock history is capped to a fixed budget, so a long-lived node keeps a small footprint. Embedded guide →
- Proofs pin an event to a window — think under a minute — not an exact instant.
- It proves time and order. Pair it with a signature when you also need to prove who.
- Like any network, its reach depends on participation — the more nodes, the tighter and more trusted the proofs.
What you gain
- Mathematical proof of when an event happened, and which of two came first.
- Proofs a third party can verify offline — no account, no platform, no trust in you.
- Freedom from fees, gatekeepers, and single points of failure.
- Privacy — publish as much as you like; only fingerprints ever leave your machine.
- Proofs that last — on a fixed storage budget a node's reach stretches back years, and further as you add chains; recent events stay pinned to the second, older ones fade in precision, and any proof it makes is valid forever.
Back of the envelope
Pick a storage budget. Everything else follows.
A node runs several clock chains at once — one fast, each of the rest a step slower — keeps a fixed number of ticks on every chain, and prunes the rest. Storage then stays flat forever: recent moments are pinned to the second, and older ones widen gently with age. Here is what a given budget buys, at a steady one tick per second.
| Device | Storage budget | Pinned to the second | A 10-year-old event | Reach |
|---|---|---|---|---|
| Raspberry Pi Zero | 64 MB | events up to ~2 hours old | bracketed to ~33 hours | ~210 years |
| Phone or laptop | 1 GB | events up to ~1.5 days old | bracketed to ~52 minutes | ~310 years |
| Small server | 32 GB | events up to ~46 days old | bracketed to ~81 seconds | ~280 years |
Reach is nearly free — it costs chains, not storage — so almost the whole budget goes to precision. Worst case, an aged event is bracketed to a fraction of its age: ~0.09% on a Pi, ~0.004% on a phone, ~0.00008% on a server. Push the tick faster than one per second — or lean on a denser, better-connected patch of the network — and even recent bounds drop well below a second, a resolution no block-time-bound chain can reach.
What it takes to build the graph
Storage
Your chosen budget, flat forever. The graph is a fixed pile of clock ticks — about a million on a phone, roughly 1 KB each — and pruning holds it there however long the node runs.
Network
One small heartbeat a second, shared as a hash with your ~10 neighbors. A complete proof is roughly 40 hops — about 40 KB, a single UDP packet. Everything else on the wire is just chain tips, about 1.25× a single chain.
CPU
A hash and a signature about once a second. Running eight clock chains at once adds only ~25% over running one. Light enough to stay always-on on a $15 Raspberry Pi Zero.
Quickstart
Three commands to publish. One to look it up.
A node runs as a background daemon (lotid); the loti client drives it over a local socket. Here is a brand-new node publishing a document — and a neighbor discovering it across the network.
# 1 · start your node $ loti init node id: 0x00000000a11ce5d0 start: lotid --key ~/.loti/key --port 7000 --control ~/.loti/control.sock $ lotid --key ~/.loti/key --port 7000 --control ~/.loti/control.sock & [lotid] node 0x00000000a11ce5d0 listening on udp/7000 (signed) $ export LOTI_CONTROL=~/.loti/control.sock # 2 · add a neighbor (id:ip:port) $ loti peer add 0x00000000b0b0cafe:203.0.113.9:7000 peer: 0x00000000b0b0cafe:203.0.113.9:7000 # 3 · publish a document $ loti publish "hello from alice" event: 2c7f9a4e8d…
# the neighbor's node is already running and peered # back to alice. alice shares the event hash; # the neighbor looks the document up over the network: $ loti chain 2c7f9a4e8d… reference: 0x00000000b0b0cafe lower: creator=0x00000000b0b0cafe hash=7a10d2… ts=1752748262000000000 event: 2c7f9a4e8d… content: hello from alice upper: creator=0x00000000b0b0cafe hash=7a2f81… ts=1752748299000000000 clockEvents: 2 # → the document, bracketed between two of the # neighbor's own clock ticks — provably.
Get started
Run a node. Stamp a moment.
Prove it to the world.
LOTI is open research and open source. Read the whitepaper for the whole idea, or dive into the code and documentation.
Questions
The things people ask first.
Is this a blockchain?
No. There's no global ledger, no coin, and no mining. Everyone keeps their own local timeline and cross-checks their neighbors, which makes LOTI far lighter, private, and free compared with a blockchain.
Is this just timestamping?
It's a timestamping network — and, at the same time, an event-ordering one. The same fabric fixes which event happened before which, as a tamper-proof partial order, whether or not you ever attach a date. Two events can be conclusively ordered against each other even when neither carries a trusted timestamp. Pin that ordering to a reference clock and you get a readable date; leave the clock out and the order still holds.
Does it cost money?
Publishing an event is effectively free. Running a node costs a bit of bandwidth and a fixed slice of storage — capped at a budget you choose and flat forever. There are no per-proof fees.
Won't the storage grow forever?
No. Each node keeps its clock history at several resolutions at once — fine-grained for recent events, progressively coarser for older ones — and trims each down to a fixed size. The clock-event store is capped at a budget you set, from tens of megabytes on a Raspberry Pi to tens of gigabytes on a server, and stays flat (published-event content is separate and grows with what you publish). Within a node's reach an old event stays orderable — its time window just widens gently with age (recent events pinned to the second, older ones coarser) — and more chains push that reach back years and beyond; a proof, once made, is valid forever.
How precise is a proof?
It depends on the network — and precision is a dial, not a fixed floor. How tight the window is comes down to two things you can scale: the heartbeat interval of the nodes on the chain, and the topology around your event — a denser, better-connected, faster-ticking stretch of the network brackets it more tightly. Push the clock faster and gather a few close neighbors and the window drops well below a second; leave it at one slow tick a node and it widens toward a minute. That tunability is something Bitcoin or Ethereum stamping can't match: there, resolution is pinned to the block interval — minutes on Bitcoin, seconds on Ethereum — and can't go finer. Worse for ordering, every event that lands in the same block carries that block's one timestamp, so within a block — about ten minutes on Bitcoin — there is no way to say which of two events came first at all. LOTI's heartbeat is continuous, so it keeps separating events right down to its resolution. Either way, a LOTI proof is a rigorous bound, never a claim of an exact instant.
Is my content made public?
No. By default only fingerprints — not your actual files — travel across the network. Your documents, photos, and measurements stay on your own machine.
Do I have to trust the other nodes?
No. A proof is checked with mathematics, so a dishonest node can't fabricate a valid one. The only thing you choose is whose clock the time is measured against — your own, or a reputable reference like a notary or a court.
Who runs the network?
Anyone. People, companies, cities, courts, laboratories, even sensors and IoT devices. The more participants there are, the tighter and more widely trusted the proofs become.
How robust is the network?
Every node keeps several neighbors, not just one, and each heartbeat is heard and echoed by many of them. That redundancy is built in from the start: links and routes overlap heavily, so nodes dropping offline — or whole regions falling quiet — leave the fabric intact and existing proofs verifiable. The more densely the network is woven, the more resilient it becomes.
Does it keep working as the network grows and changes?
A proof traces the network as it was when your event happened — not as it looks today — so peers coming and going never invalidates an old proof. To stay fast as the network grows, a lookup heads straight for its destination where the route is known and falls back to a bounded search where it isn't. However it's found, every proof is re-checked by the math, so a wrong turn can only make a lookup miss — never make it lie.