Method
How it holds up. And where it stops.
Noeten is a concept with a working prototype. This page says what each part does, how it is checked, and the limits that come with it.
What stays local.
Log files are read by the coordinator from its inbox folder and streamed to workers over your own network. Archives are written to your own shared folder. No part of the queue talks to any server outside your network.
The website never receives a log. The demo reads your file inside the tab. The testnet sample is fetched from the chain's public RPC through this site's server, which keeps it for at most 15 seconds.
The ledger receives, only if you anchor: the manifest's sha256, the Merkle root, file count, total sizes, a hash of the tool name, and the source chain and block range. File names go into the tree as hashes.
How archives are checked.
Worker: hashes the original while it streams in and compares with the coordinator's hash, compresses, then decompresses its own archive and compares sha256 and size again before reporting.
Coordinator: does not trust the worker or the shared folder. It opens the archive without following symlinks and only if it is a regular file inside the share, rejects implausible sizes, stops decompressing past the original size, enforces a time limit, and compares both hashes itself. A file that fails goes back to the queue, up to three attempts.
Leases: a worker that stops answering loses its job after the lease time and another machine picks it up. Each worker holds one job at a time.
Access: a shared token on every call, and only loopback and private-range callers by default. The token is a team secret, not an identity: anyone who has it can act as a worker.
What the ledger proves.
NoetenArchiveLedger stores, per team, who may write (the owner and registered worker keys) and one record per anchored run. A file entry proves into a run with a short Merkle proof (leaves prefixed 0x00, inner nodes 0x01 with sorted children), checked by the verifyFile view.
It proves that a team member stated this run at this time. It cannot prove the archive still exists, that the logs were complete, or who wrote them. A run can be retracted by its poster or the team owner; it stays readable and its manifest cannot be anchored again by that team.
No owner, no fee, no upgrade, no ether: sending value reverts. Gas measured on a Robinhood Chain fork: create team about 105,000, add worker about 102,000, anchor run about 273,000.
Not deployed yet. When it is, its address appears in the footer and on the ledger page, and the deployment can be checked byte for byte with the repository's verify-deployment script.
Status of every part.
One machine queues the log files, hands one job at a time to each idle machine, re-checks every archive it gets back and writes the run manifest.
One local network, one coordinator. Runs from the source code in examples/lan-queue (Node 20+). Not a hosted service.
Any team computer pulls a job only while its load is low, streams the file over the LAN, compresses it with zstd, brotli or gzip, and proves the archive opens to the exact original.
Idle means a low load average; on Windows it cannot be read, so the worker counts as always idle.
Drop a log file, or use a sample built from the newest Robinhood Chain testnet blocks, and compress it in this tab. Ratio and sha256 of both sides.
Uses the browser's own gzip and deflate. Your file never leaves the tab.
NoetenArchiveLedger: a team registers its worker keys and anchors each run (manifest sha256, Merkle root, sizes, source block range). Anyone can prove one file belongs to a run.
Contract written and tested, not deployed yet. Hashes and sizes only; it cannot know if an archive still exists.
Blocks per second, event logs per block and log bytes on Robinhood Chain mainnet and testnet, read live, with the formula behind every estimate.
Counts event logs from the RPC only. A node's own debug logs are larger and are not visible from here.
Queues that span two offices or a home and an office.
Not built. Today everything stays on one local network.
A token for larger teams or extra features once they exist.
Not built, not needed. Every prototype above works without it.
Known limits.
One local network per queue; nothing routes between sites. One coordinator; if it stops, the run stops (archives already written stay valid and can be checked).
Idle detection uses the load average, which is coarse, and is not available on Windows.
The browser demo has gzip and deflate only; zstd and brotli run on the workers.
The scripts and the contract are new and have not had an independent security review. Try them on test logs first.
Questions.
What is Noeten?
A log compression queue for one team's local network. One computer acts as coordinator and queues the testnet log files; the team's other computers pull jobs while they are idle, compress the files, check that every archive opens to the exact original, and write it to a shared folder. The project is at concept stage: what runs today is a working prototype of that loop, the in-browser demo, the live network figures and the ledger contract.
Are my logs uploaded anywhere?
No. The coordinator and workers talk only over your own network and write only to your own shared folder. The demo on this site compresses in your browser tab and sends nothing. The optional ledger stores hashes, sizes and counts, never a log line or a file name.
Can this website see my local network?
No. A website cannot reach machines on your LAN, and this one does not try. You run the coordinator and workers yourself from the source code; the site shows how, and checks a manifest file you drop into it, inside your browser.
How do I know an archive is complete?
The worker decompresses its own archive and compares sha256 and size with the original before reporting it. The coordinator then reads the archive from the shared folder and does the same check again, with a size cap and a time limit. Only archives that pass both go into the run manifest.
What does the ledger add?
A public, timestamped record that a run with this manifest existed. Later, anyone holding a file and its archive can prove that pair belongs to the anchored run with a short Merkle proof. The ledger cannot know whether you still keep the archive, and the contract is not deployed yet.
What does it cost to run?
The queue costs nothing beyond the computers you already have. Anchoring a run is one Robinhood Chain transaction paid in ETH by the team member who sends it.
Do I need the $NOETEN token?
No. Every Prototype feature works without it. Token use is a Concept. The contract address is published at launch; until then it reads TBA.