Proof of when · peer‑to‑peer · no middleman
Prove when it happened.
To anyone. Without
trusting anyone.
LOTI links every digital event into a shared, hash-linked record of time — so you can prove both when a document, photo, message, or measurement existed, to within a narrow window, and which of two events came first. Not just a timestamp: a verifiable ordering of events.
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 has to trust, LOTI has every node keep time together. About once a second each node emits a small signed record called a clock event, and each one embeds a few hashes: the node's own previous clock event, and the most recent clock events it has heard from its neighbors.
Those hashes are the links. Pointing back at its own previous clock event puts each node's ticks in order; referencing its neighbors' clock events stitches the separate timelines together. Taken as a whole, this is one ever-growing, hash-linked graph — a directed acyclic graph, or DAG — in which every link means "this record already existed when that one was made." Only the hash of each clock event goes on the wire, sent over UDP to a handful of direct neighbors, so almost nothing about your machine leaves it.
The graph only ever grows at the front, and that is what makes it tamper-evident. Change anything already inside it and every hash computed from it stops matching — on your machine and on every neighbor that kept a copy. Nobody has to enforce a rule; the hashes simply stop lining up. That is the concrete reason you can't forge the past and can't pre-compute the future.
There's no global vote and no single winner. Each node assembles its own view of the graph from what it hears, and any two views can be lined up wherever they overlap. Nodes never have to agree on one timeline — only, link by link, on what came before what. So two nodes can hold different views and still never prove a contradiction.
Two proofs from one graph. LOTI is a timestamping network — and the same graph 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 ordered 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.
Anatomy of a proof
A chain that begins and ends at your own clock.
A proof is a chain of those hash links. It sets out from a clock event of the reference you trust, threads through clock events of nodes across the network, reaches the event in question, and returns to a later clock event of that same reference — pinning the event between one tick that provably came before it and one that provably came after.
Publishing an event staples it into the graph. The event embeds the hash of a recent local clock event, which places it after that tick; the next clock events its node emits reference the event back, placing it before those. So moments after it is published, the event already sits bracketed by earlier and later clock events — each of which is, in turn, linked to its neighbors'.
To read that as a time, a node follows the links from one of its own clock events, hop by hop, out to the target event and back to a second clock event of its own. Because both ends are ticks of a clock it chose to measure against — its own, a lab's, a notary's — those two bracketing ticks are the lower and upper bound, and the reference clock is what turns them into a date you can read. Nothing in the chain is asserted after the fact; it is a record of links that already existed, in the only order their hashes allow, which is why it can't be re-told two ways.
Finding the chain across the network
The links point backward — an event knows the clock event it came after, not the ones that will later enclose it — so a node usually can't assemble the whole chain from its own copy. It sends a discovery request toward the event's creator. Each node along the way contributes clock events from its own chain, extending the bracket a little further, and forwards the request on; the response then retraces the path home, and every hop fills in the forward links the requester was missing. The chain that comes back is short: roughly forty clock events for a hop out and back on both the lower and upper side — small enough to fit in a single UDP packet.
Where a node knows a route toward the creator, it forwards straight there. Where it doesn't, it falls back to a bounded search rather than flooding the whole network — a capped fan-out, a hop limit, and a visited set so a request can't loop. The search also aims at the network as it was cross-linked around the event's own time, not as it looks today, which is why peers joining and leaving later never invalidate a proof that was already found.
Routing is only ever a guess about where to look, never a claim about what is true. Every chain a discovery returns is re-checked link by link before it is trusted — hashes recomputed, each link confirmed, both ends confirmed to be the requester's own clock events. A wrong turn can only make a search come back empty, or with a looser bound; it can never make it return a false one. Two nodes may find different chains, but never contradictory ones.
You can't forge the past
The moment a clock event is broadcast, 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 graph has set, and validation rejects any chain whose hashes 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 shared graph 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. Its hash is linked into the graph 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 clock event 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 graph 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 tick 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 clock ticks continuously, 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 clock event 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 graph intact and existing proofs verifiable. The more densely the network is connected, 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.