# https://yore.steddle.com Launching soon What they said, and when they stopped. ====================================== Choose the pages of a website, the languages and the years. Yore pulls every archived version, shows what changed, section by section, and exports it as evidence. How it works A timeline in three steps. -------------------------- 1. ### Choose Name a website. Yore reads its sitemaps and the archive's index, including the pages that are gone today, and you tick the ones that matter, in the languages and the years you need. 2. ### Compare Yore fetches each distinct capture once and sets two moments of a page against each other, section by section and word by word, the way bron compares two versions of a law. 3. ### Export Every capture leaves with its archive date, its status and its SHA-256, in one zip anyone can check offline, without asking us. Evidence Made to be checked. ------------------- 1. ### The capture, not a copy Each version is the archive's own bytes, hashed the moment they arrive and checked against the archive's digest, with the date the archive took them. 2. ### Every image dated An image keeps the date of its own capture, so a page never borrows a picture from another year without saying so. 3. ### Going forward A page you watch is checked every day under Yore's own name. A change is captured at the next check, and the Internet Archive is asked for a capture of its own. --- # https://yore.steddle.com/docs Docs. ===== How to make a plan and read a page through the years, what a capture proves and what it doesn't, how anyone checks an export, and how an agent or a terminal does the same work. 01 Start here ---------- 3 articles [What Yore is A timeline of a website from the Internet Archive's captures, and what Yore deliberately does not do. ](https://yore.steddle.com/docs/getting-started/what-yore-is) [Make a plan Name a website, choose its paths, languages and years, read the archive's index, tick the pages and fetch them. ](https://yore.steddle.com/docs/getting-started/make-a-plan) [Read a page Versions, two moments side by side, the life of a sentence, what changed across the plan, and two languages at one moment. ](https://yore.steddle.com/docs/getting-started/read-a-page) 02 Topics ------ 4 topics | 12 articles 3 articles [Getting started --------------- What Yore does, how to make a plan for a website, and how to read a page through the years. ](https://yore.steddle.com/docs/getting-started)- [What Yore is](https://yore.steddle.com/docs/getting-started/what-yore-is) - [Make a plan](https://yore.steddle.com/docs/getting-started/make-a-plan) - [Read a page](https://yore.steddle.com/docs/getting-started/read-a-page) 4 articles [Evidence -------- What a capture proves and what it does not, and how anyone can check an export, an exhibit or a shared comparison. ](https://yore.steddle.com/docs/evidence)- [What a capture proves](https://yore.steddle.com/docs/evidence/what-a-capture-proves) - [Exports](https://yore.steddle.com/docs/evidence/exports) - [Exhibits and share links](https://yore.steddle.com/docs/evidence/exhibits-and-share-links) - [Verify a file](https://yore.steddle.com/docs/evidence/verify-a-file) 1 article [Going forward ------------- Pages Yore checks itself, once a day, so a change is captured at the next check that sees it. ](https://yore.steddle.com/docs/going-forward)- [Watch a page](https://yore.steddle.com/docs/going-forward/watch-a-page) 4 articles [Agents ------ Yore over MCP for Claude and other clients, and the yore command for a terminal. ](https://yore.steddle.com/docs/agents)- [Connect over MCP](https://yore.steddle.com/docs/agents/connect-over-mcp) - [The tools](https://yore.steddle.com/docs/agents/the-tools) - [The yore command](https://yore.steddle.com/docs/agents/the-command) - [Tokens](https://yore.steddle.com/docs/agents/tokens) --- # https://yore.steddle.com/docs/getting-started [ Docs ](https://yore.steddle.com/docs) Getting started. ================ What Yore does, how to make a plan for a website, and how to read a page through the years. 01 Getting started --------------- 3 articles [What Yore is A timeline of a website from the Internet Archive's captures, and what Yore deliberately does not do. ](https://yore.steddle.com/docs/getting-started/what-yore-is) [Make a plan Name a website, choose its paths, languages and years, read the archive's index, tick the pages and fetch them. ](https://yore.steddle.com/docs/getting-started/make-a-plan) [Read a page Versions, two moments side by side, the life of a sentence, what changed across the plan, and two languages at one moment. ](https://yore.steddle.com/docs/getting-started/read-a-page) --- # https://yore.steddle.com/docs/getting-started/what-yore-is [ Docs ](https://yore.steddle.com/docs) [ Getting started ](https://yore.steddle.com/docs/getting-started) What Yore is ============ A timeline of a website from the Internet Archive's captures, and what Yore deliberately does not do. 01 Getting started --------------- Article 1 of 3 Yore builds a timeline of a website. You choose the pages, the languages and the years. Yore asks the Internet Archive for every capture it holds of those pages, fetches each distinct one once, and shows what the page said at each moment and what changed between two of them, word by word. Everything Yore shows rests on a capture you can open yourself: the archive's own address for it, its time in UTC, the status the site answered with, and the SHA-256 of the bytes Yore fetched. What you do with it ------------------- - [Make a plan](https://yore.steddle.com/docs/getting-started/make-a-plan) for a website: its paths, its languages and a window of time. - [Read a page](https://yore.steddle.com/docs/getting-started/read-a-page) as versions, compare two moments, and trace one sentence from the capture that first shows it to the capture that first lacks it. - See which pages changed, appeared or were removed, month by month. - Take it out as [an export](https://yore.steddle.com/docs/evidence/exports) anyone can check without asking Yore, as a printed [exhibit](https://yore.steddle.com/docs/evidence/exhibits-and-share-links), or as a read-only link. - [Watch a page](https://yore.steddle.com/docs/going-forward/watch-a-page), so a change from today on is captured at the next daily check that sees it. The site, the [MCP server](https://yore.steddle.com/docs/agents/connect-over-mcp) and the [yore command](https://yore.steddle.com/docs/agents/the-command) give the same answers: all three ask one API. Where the past comes from ------------------------- The past comes from the Internet Archive's Wayback Machine, and from nowhere else. Yore reads the archive's index to learn which captures exist, and fetches the raw bytes of a capture, without the archive's banner or rewritten links. It names itself in every request and keeps to the archive's pace: one request every 1,5 seconds, shared by every plan. From the day you watch a page, Yore also checks the page itself once a day and keeps what it answers. What Yore is not ---------------- - **Not a law firm.** Yore states what the captures show. It gives no legal advice and draws no conclusion about what a change means. - **Not a way past a door.** Yore reads public pages. It doesn't sign in anywhere, doesn't pass a paywall, and doesn't get around bot protection. A site that refuses Yore's own request is recorded as blocked. - **Not a replay.** Yore keeps a page's HTML and the images in its content. It doesn't keep stylesheets, scripts or fonts, so it shows what a page said, not how it looked. The capture's address in the web archive shows that. - **Not a guess.** The text of a page is derived from its bytes by fixed rules. No model reads or rewrites it, so the same bytes always give the same text. - **Not a continuous record.** The archive visits a page when it visits. Between two captures nobody looked, and Yore never claims a page said something on a day without a capture. Checked against the code on 1 October 2026. [ Make a plan ](https://yore.steddle.com/docs/getting-started/make-a-plan) --- # https://yore.steddle.com/docs/getting-started/make-a-plan [ Docs ](https://yore.steddle.com/docs) [ Getting started ](https://yore.steddle.com/docs/getting-started) Make a plan =========== Name a website, choose its paths, languages and years, read the archive's index, tick the pages and fetch them. 01 Getting started --------------- Article 2 of 3 A plan is how Yore reads one website: its domains, the paths to follow, the languages, a window of time, and how many captures of each page to fetch. An account holds 3 plans, and a plan holds 1.000 ticked pages. Name the website ---------------- Choose **New plan** and type the domain, `tesla.com`. If the site lived on another domain before, add it after a comma: `tesla.com, teslamotors.com`. A plan takes five domains at most. Give the first and last day you want to see, or leave them empty for everything the archive holds. Yore then reads what the site lists of itself: its sitemaps today, the archive's copy of them where the site refuses Yore, and the archive's copies from earlier years. Those older sitemaps are how pages that are gone today show up. Choose paths and languages -------------------------- Under **Rules**, the list **What the site holds** shows the site as a tree: each path with how many pages lie under it. Open a path to look inside it. **Follow** adds that one page, and **Follow all under it** adds every page that starts with it. Above the tree, **Follow the home page** adds `/` and **Follow the whole site** adds `/*`. You can also type a path by hand. The archive's index often knows pages no sitemap lists. - **Paths.** A path is one page: `/` is the home page, `/about` that page. A path that ends in `*` is every page that starts with it: `/model3*` takes `/model3`, `/model3/design` and `/model3-performance`, and `/*` is the whole site. A page followed by itself comes without its variants that carry a query string. - **Languages.** Yore reads a language from the start of a path, `/nl_nl/model3` or `/en-gb/pricing`. Tick the ones you want. With none ticked, Yore reads every language it knows for the site, and the pages with no language in their path. - **How many captures.** Every distinct capture, one a week, or one a month. A page that changes on every load has a different capture each time the archive visits. One a month keeps such a page to a dozen fetches a year. Yore always fetches a page's last capture in the window too. Read the archive's index ------------------------ **Save and read the archive** asks the archive's index for every page your paths name, in each language, and for every capture of each page: its time, the status the site answered with, and a digest of what the archive stored. That includes captures of a 404 and of a redirect, which is how Yore sees a removal. It costs one request or a few per path and language and runs in the background. An address the archive only ever saw refuse, such as a probe for `/.well-known/nodeinfo`, is left off the plan unless a sitemap names it: there is nothing to read on it. Scripts, stylesheets, images and videos are left off too. Reading a site, reading the index and fetching all run in the background. If a plan is busy and Yore hasn't heard from its job for 15 minutes, the plan says so and offers **Start again**. What was already read is kept. Once the index is read, **Save** applies what you changed and nothing else. A path or language you take away takes its pages off the plan at once, without a request to the archive. One you add is read from the archive's index in the background, while the plan's other pages stay in view and in use. **Save and read the archive again** also asks the archive what it captured since, for every path it read a day or more ago. While Yore reads the index or fetches, the rules are closed. A plan that fetches opens them once you pause it. If the archive holds more under a path than Yore reads in one go, the plan says so and asks you to narrow the path. Tick the pages -------------- Every page the index knows under your rules is on the plan, ticked. Untick what you don't need. Only ticked pages are fetched, compared and exported. You can search by address, filter by language, show only pages the archive records as removed or redirected, and sort by the number of captures. With a filter on, the menu beside the list ticks or unticks every page that matches. Past 1.000 pages, the pages with the fewest captures lose their tick. See what a run costs -------------------- **Coverage** states, before anything is fetched: the ticked pages, the captures in the window, the distinct captures to read, how many of those Yore already holds, how many requests remain, and how long that takes at the archive's pace. A bar per year shows how densely the archive covers the window. A capture another plan fetched before costs nothing: Yore keeps every capture once, under the hash of its bytes. Fetch ----- **Fetch** starts the run. Yore makes one request every 1,5 seconds, about 40 a minute, for every plan together. Plans take turns, one request each, so a large plan never holds a small one up. You can pause a run and resume it. When the pages are in, Yore derives each one's text, groups a page's captures into [versions](https://yore.steddle.com/docs/getting-started/read-a-page), reads [removals](https://yore.steddle.com/docs/evidence/what-a-capture-proves#removals) from the archive's record, and then fetches the images of each version, 40 a version at most. A capture the archive refuses three times is given up on, and the run moves on. A busy plan states where it stands under its name, on every tab and on its row in the list of plans: the step it is on, how much of it is done, and how long the rest takes at the archive's pace. A run that took ten minutes or more ends with a mail to the plan's owner, when it is done and when it stopped before that. Checked against the code on 1 October 2026. [ What Yore is ](https://yore.steddle.com/docs/getting-started/what-yore-is) [ Read a page ](https://yore.steddle.com/docs/getting-started/read-a-page) --- # https://yore.steddle.com/docs/getting-started/read-a-page [ Docs ](https://yore.steddle.com/docs) [ Getting started ](https://yore.steddle.com/docs/getting-started) Read a page =========== Versions, two moments side by side, the life of a sentence, what changed across the plan, and two languages at one moment. 01 Getting started --------------- Article 3 of 3 Open a page from a plan's **Pages** list. Its heading states how many captures the archive holds, how many versions Yore read, and the first and last capture. If the archive records the page as removed or redirected, a notice says since when and whether that is confirmed. Versions -------- A version is a run of consecutive captures in which the page reads the same. It runs from its first capture to its last, and states how many captures show it. The archive didn't look between captures, so a change is dated to the capture that first shows it, never to a day in the gap. Two captures count as the same version when the page's own text is the same. Lines the site repeats across its pages, a menu or a footer, don't make a new version. The timeline ------------ Under **Versions**, a bar lays the page's versions out in proportion to time, hatched where the archive holds no capture in between, over a table of them, newest first. A version's dates read it. Its check puts it in a comparison: one check on is the version you read, two are the versions compared. Its count of captures shows what changed with it, beside the version before. Every one of those is an address, so a comparison can be bookmarked or sent to someone on the plan. Compare two moments ------------------- With two checks on, Yore sets the two versions against each other. It matches the page's sections by their headings and shows each changed section word by word: what went is struck through, what came is marked. It says how many words went and came, and how many sections read the same. Beside the comparison, each side states its capture: the time, the status, the SHA-256 of the bytes, whether they match the archive's digest, and a link that opens the capture in the web archive. The whole page -------------- By default Yore compares the page's own content. It leaves out the site's navigation, header and footer where the page marks them as such, and sets aside any line that stands on at least 30% of the site's fetched pages, and on at least five. That is Yore's reading of the page. Switch on **The whole page, menus and footer included** to compare everything a reader could see, with nothing set aside. Use it when the change you're after sits in a menu, a banner or a footer. One version ----------- With one check on, Yore shows the page as it read during that version, in sections, with its capture beside it and its images under it. A page that never changed has one version, and opens on it. Each image states the date of its own capture and how many days that is from the page's. [Why that matters](https://yore.steddle.com/docs/evidence/what-a-capture-proves#images). The life of a sentence ---------------------- **A sentence** traces one phrase. Quote it as the page printed it. Yore searches the whole text of every version and answers with a window: the first capture that carries the sentence, the last one, how many captures prove it, the longest stretch without a capture in between, the capture before the window that lacks it, and the first capture after it that lacks it. A sentence that left and came back has two windows. Letter case, curly quotes, dashes and runs of spaces don't count. Everything else must match. On a plan, the same search runs across every ticked page. What changed across the plan ---------------------------- A plan's **Changes** tab lists, month by month and newest first, every page that first appeared, read differently, or was removed or redirected. A change links to its comparison. Two languages, one moment ------------------------- **Languages** shows the same page in the site's other languages on a date you choose. Yore pairs pages by the `hreflang` links the page itself carries, or by the same path under another language. Each column is that language's latest capture on or before the date, so two columns can be days or months apart. Each states its own capture. Checked against the code on 1 October 2026. [ Make a plan ](https://yore.steddle.com/docs/getting-started/make-a-plan) --- # https://yore.steddle.com/docs/evidence [ Docs ](https://yore.steddle.com/docs) Evidence. ========= What a capture proves and what it does not, and how anyone can check an export, an exhibit or a shared comparison. 02 Evidence -------- 4 articles [What a capture proves The capture's time, status and digest, the hash of the bytes, what a version and a removal are, and why an image has a date of its own. ](https://yore.steddle.com/docs/evidence/what-a-capture-proves) [Exports One zip with every ticked page, a manifest that names each file by its hash, and how to check it by hand or with the yore command. ](https://yore.steddle.com/docs/evidence/exports) [Exhibits and share links One comparison as a PDF to file, or as a read-only link to send. ](https://yore.steddle.com/docs/evidence/exhibits-and-share-links) [Verify a file Hand Yore a manifest or an exhibit and see whether it issued a file with those bytes, and when. ](https://yore.steddle.com/docs/evidence/verify-a-file) --- # https://yore.steddle.com/docs/evidence/what-a-capture-proves [ Docs ](https://yore.steddle.com/docs) [ Evidence ](https://yore.steddle.com/docs/evidence) What a capture proves ===================== The capture's time, status and digest, the hash of the bytes, what a version and a removal are, and why an image has a date of its own. 02 Evidence -------- Article 1 of 4 A capture is the Internet Archive's record of one visit to one address. Everything Yore says about the past rests on captures, so it matters what one proves and what it doesn't. What the archive records ------------------------ - **The time**, in UTC, to the second. Yore prints it as the archive states it. - **The status** the site answered with: 200 for a page, 404 for one that isn't there, 301 for a redirect. - **A digest** of what it stored: the SHA-1 of the payload, written in base32. On captures since 2025 the index also states it as `sha256:` followed by the SHA-256 in hex. Every capture has an address in the web archive, which Yore links. Anyone can open it and see the archive replay that visit. What Yore adds -------------- Yore fetches the raw bytes of a capture and keeps them under their SHA-256. Bytes are never overwritten: the same content is stored once, and a different content gets a different name. Yore then computes the archive's kind of digest over those bytes and says whether it matches the one in the archive's index. A match means the bytes Yore holds are the payload the archive recorded. Where they differ, Yore says so and doesn't hide the capture. The text -------- The text of a page is derived from its bytes by fixed rules: headings, paragraphs, list items, table cells and the addresses of images, in the order the page has them. Scripts, styles and hidden elements are left out. No model takes part, so the same bytes always give the same text. Yore derives two texts. The whole text is everything a reader could see. The content leaves out the site's navigation, header and footer. An [export](https://yore.steddle.com/docs/evidence/exports) carries both, each named by its hash. A version, and the gaps ----------------------- A version runs from the first capture that reads a certain way to the last. That window is what the captures prove. Between two captures the archive didn't look: the page may have changed and changed back, and nobody would know. So a change is dated to the capture that first shows it. Yore also states the capture before it, which is the latest moment the old text is proven. The change happened between the two. Removals -------- Yore reads a removal from the archive's record of a page, by a fixed rule: - A 404, a 410 or a 451 is an indication. Three of them, each at least 24 hours after the one before, with no capture of the page since, confirm the removal. Until then it's shown as open. - A redirect counts once it has been held for 72 hours, across two captures or more, on the address that last answered with the page. A redirect from `http` to `https`, or from another spelling of the address, is routine and never counts. - Once the archive sees the page again, the removal is resolved. The removal is dated to the first capture that shows it. For a page you [watch](https://yore.steddle.com/docs/going-forward/watch-a-page), Yore's own checks follow the same three-sightings rule. Images have their own date -------------------------- The archive keeps an image apart from the page that shows it, and often captured it in another month or year. When it replays a page from 2019, it fills in the nearest image it has, which may be from 2021. A court can set a capture aside for that. So Yore reads the archive's index for each image and takes the capture nearest the version's first day. It keeps that image under its SHA-256 and states the image's own capture date, and how many days before or after the page's that is. Yore fetches the images inside a page's content, 40 a version at most, from `img` elements. It doesn't fetch background images set in a stylesheet. Checked against the code on 1 October 2026. [ Exports ](https://yore.steddle.com/docs/evidence/exports) --- # https://yore.steddle.com/docs/evidence/exports [ Docs ](https://yore.steddle.com/docs) [ Evidence ](https://yore.steddle.com/docs/evidence) Exports ======= One zip with every ticked page, a manifest that names each file by its hash, and how to check it by hand or with the yore command. 02 Evidence -------- Article 2 of 4 An export is one zip with everything a plan found, made so that a reader can check it without asking Yore anything. Make one on a plan's **Export** tab with **Make an export**. It's built in the background and listed there with its size and the SHA-256 of its manifest. A plan needs at least one fetched page. What it holds ------------- - `manifest.json`: every ticked page, every capture the archive holds of it in the plan's window, every version Yore read, and the SHA-256 of every file in the zip. - `captures/`: the bytes of the first capture of each version, as the archive stores them, each file named by its SHA-256. Where the site sent the page compressed, the archive stored it compressed, and so does the export: the manifest states the file's `encoding`, and `gzip -dc` reads a `gzip` one. - `texts/`: the two texts Yore derived from those bytes, the whole page and its content, each named by its SHA-256. - `assets/`: the images of the versions, each named by its SHA-256. - `README.txt`: what is in the zip and how to check it. The files are stored in the zip without compression, so any tool can hash one straight out of it. The manifest ------------ For every page the manifest states: - its address, its language, and how Yore learned of it; - its removal, if the archive shows one: the kind, since when, and whether it's confirmed; - its coverage: the number of captures, the first and the last, the captures per year, and the longest gap between two captures in days; - every capture in the window, whatever its status: the time in UTC, the address captured, the address in the web archive, the status, the type and the archive's digest; - every version: its first and last capture, how many captures show it, the SHA-256 of its bytes and of its two texts, and its images, each with the date of its own capture and how many days that is from the page's. For every file it states the path, the SHA-256 and the size in bytes. A capture's entry adds its encoding where it has one, the archive's digest, whether the bytes match that digest, the address they were fetched from and when. An image's entry adds its encoding, the archive's digest and whether the bytes match it. A text's entry has the three alone: it is Yore's derivation, and the archive holds no digest of it. The SHA-256 of `manifest.json` itself names the export. It's what the **Export** tab lists and what [the verify page](https://yore.steddle.com/docs/evidence/verify-a-file) recognises. Check it by hand ---------------- Every file is named by its own hash, so the check is one command on any machine: ``` unzip export.zip -d export cd export shasum -a 256 captures/* assets/* ``` Each line must print a hash equal to the file's name. A text is named the same way, with `.txt` after the hash. To check a capture against the archive itself, take its `snapshot_url` from the manifest and put `id_` after the timestamp. That address answers the raw bytes: ``` curl -sL -H 'Accept-Encoding: gzip' https://web.archive.org/web/20190102084842id_/https://www.tesla.com/model3 | shasum -a 256 ``` Check it with the command ------------------------- ``` yore verify export.zip ``` The [yore command](https://yore.steddle.com/docs/agents/the-command) hashes every file, compares it with the manifest, and recomputes the archive's digest of every capture. It works offline and needs no account. It exits with 6 if anything in the export doesn't verify. What it does not hold --------------------- An export carries no timestamp from a third party and no signature. It proves that its files are what the manifest names, and each capture can be checked against the archive. It doesn't prove on its own when the export was made: [the verify page](https://yore.steddle.com/docs/evidence/verify-a-file) states when Yore issued it. Checked against the code on 1 October 2026. [ What a capture proves ](https://yore.steddle.com/docs/evidence/what-a-capture-proves) [ Exhibits and share links ](https://yore.steddle.com/docs/evidence/exhibits-and-share-links) --- # https://yore.steddle.com/docs/evidence/exhibits-and-share-links [ Docs ](https://yore.steddle.com/docs) [ Evidence ](https://yore.steddle.com/docs/evidence) Exhibits and share links ======================== One comparison as a PDF to file, or as a read-only link to send. 02 Evidence -------- Article 3 of 4 An export carries a whole plan. An exhibit and a share link carry one comparison: what one page said at two moments. Both start from a page's **Versions** tab, with two versions checked. An exhibit ---------- **Print as an exhibit** makes a PDF on A4 and downloads it. It holds: - the page's address, the two moments compared, and how many words went and came; - for each side: the version's first and last capture, how many captures show it, the time of its first capture in UTC, the status the site answered with, the address in the web archive, the SHA-256 of the bytes, and the archive's digest with whether the bytes match it; - the removal, if the archive shows one for the page; - every changed section, word by word: what went is struck through, what came is bold and underlined; - how to read it, and how to check it without Yore. With **The whole page** switched on, the exhibit compares the whole page and says so. Yore keeps each exhibit under the SHA-256 of the PDF. [The verify page](https://yore.steddle.com/docs/evidence/verify-a-file) recognises the file and states when it was made. A changed copy isn't recognised. A share link ------------ **Share this comparison** makes a link. Whoever holds it sees that one comparison, read-only, without signing in: the two captures with their hashes and web archive addresses, and the changed sections. Nothing else of the plan is reachable through it. A shared page is kept out of search engines. The link is long and random, but it isn't a secret you control once you've sent it: anyone it's forwarded to can open it. Revoke a link ------------- A page lists its own open links beside its comparison, each with **Revoke**. A plan's **Export** tab lists every share link of the plan under **Share links**, with the page it shows and when it was made. **Revoke** closes a link for everyone who holds it. A revoked link answers with a refusal, and can't be opened again. Deleting a plan removes its links and its exports. Checked against the code on 1 October 2026. [ Exports ](https://yore.steddle.com/docs/evidence/exports) [ Verify a file ](https://yore.steddle.com/docs/evidence/verify-a-file) --- # https://yore.steddle.com/docs/evidence/verify-a-file [ Docs ](https://yore.steddle.com/docs) [ Evidence ](https://yore.steddle.com/docs/evidence) Verify a file ============= Hand Yore a manifest or an exhibit and see whether it issued a file with those bytes, and when. 02 Evidence -------- Article 4 of 4 The [verify page](https://yore.steddle.com/verify) answers one question: did Yore issue this file? It works for two kinds of file, and needs no account. - the `manifest.json` of an [export](https://yore.steddle.com/docs/evidence/exports), exactly as the zip holds it; - the PDF of an [exhibit](https://yore.steddle.com/docs/evidence/exhibits-and-share-links). How it works ------------ Choose the file and press **Check the file**. Yore takes the file's SHA-256, looks it up among the exports and exhibits it issued, and deletes the file. It keeps nothing of it. A file may be 20 MB at most, and one address may check ten files a minute. A match states that Yore issued a file with exactly these bytes, and when. For an export it adds how many pages and captures the manifest states. It never says whose plan it was or what the file holds. No match says nothing about a file. It may be Yore's and changed since, by one byte, or it was never Yore's. By hash ------- If you'd rather not upload the file, hash it yourself and ask by hash: ``` shasum -a 256 manifest.json curl https://yore.steddle.com/api/v1/verify/ ``` The answer is the same, as JSON. `yore verify export.zip --online` does both steps after its own check. Without Yore ------------ None of this is needed to trust an export's contents. Every file in an export is named by its hash, and each capture can be fetched again from the web archive. [Check it by hand](https://yore.steddle.com/docs/evidence/exports#check-it-by-hand), or run `yore verify` offline. Checked against the code on 1 October 2026. [ Exhibits and share links ](https://yore.steddle.com/docs/evidence/exhibits-and-share-links) --- # https://yore.steddle.com/docs/going-forward [ Docs ](https://yore.steddle.com/docs) Going forward. ============== Pages Yore checks itself, once a day, so a change is captured at the next check that sees it. 03 Going forward ------------- 1 article [Watch a page A daily check under Yore's own name, what each outcome means, and the second witness it asks the archive for. ](https://yore.steddle.com/docs/going-forward/watch-a-page) --- # https://yore.steddle.com/docs/going-forward/watch-a-page [ Docs ](https://yore.steddle.com/docs) [ Going forward ](https://yore.steddle.com/docs/going-forward) Watch a page ============ A daily check under Yore's own name, what each outcome means, and the second witness it asks the archive for. 03 Going forward ------------- Article 1 of 1 The archive visits a page when it visits. For a page that matters from today on, that's not enough: a change next month is only caught if the archive happens to pass by. Watch the page, and Yore checks it itself once a day. Watch a page ------------ Open the page from its plan and choose the **Going forward** tab, then **Watch this page**. Every watched page is checked once a day, at 04:30 UTC. **Check now** runs a check at once, at most once a minute per page. **Stop watching** ends it. A check is one request from Yore to the site, under Yore's own name. Yore doesn't pretend to be a browser, doesn't sign in, and follows ten redirects at most. What a check finds ------------------ - **Captured.** The first time the page answers. Yore keeps the bytes under their SHA-256, as a capture of its own with the time of the check, and reads their text. - **Unchanged.** The page's content reads as it did at the last check. The check still counts as a capture: it proves the text stood on that day. - **Changed.** The content reads differently. The capture becomes a version in the page's timeline, to compare with any other. - **Removed.** The site answered 404, 410 or 451. That opens a removal. Three such checks, each at least 24 hours after the one before, confirm it. If the page answers again, the removal is resolved. - **Blocked.** The site refused the request, with a 403, a 429 or a server error, or answered with something that doesn't read as the page: a redirect to the front page, or less than a fifth of the text the page last had. - **No answer.** The site didn't respond. Every check is listed under **Going forward** with its time, the status, and the hash of what was captured. The list only grows: a check is never rewritten. Blocked says nothing about the page ----------------------------------- A refusal isn't the page. Yore records it and never hashes it, because a block page compared with a block page would read as the page unchanged, and that's a claim Yore has no ground for. When a site blocks a daily check, Yore reads the archive's index for that page again, so whatever the archive captured since is known and a removal the archive saw still shows. Yore doesn't get around bot protection. A page behind it is not captured going forward: it shows as blocked, with the archive's captures beside it. A second witness ---------------- A capture of Yore's own is Yore's word. So when a check captures a page for the first time, finds it changed or finds it removed, Yore also asks the Internet Archive to capture the page, through Save Page Now. The check notes that it asked. The archive's capture then appears among the page's captures the next time the index is read, under the archive's own timestamp. Yore asks only where it holds an Internet Archive account's keys, and the archive may refuse or be blocked by the site itself. A witness that didn't come never fails the check. Checked against the code on 1 October 2026. --- # https://yore.steddle.com/docs/agents [ Docs ](https://yore.steddle.com/docs) Agents. ======= Yore over MCP for Claude and other clients, and the yore command for a terminal. 04 Agents ------ 4 articles [Connect over MCP The server's address, connecting Claude, the consent screen, limits and disconnecting. ](https://yore.steddle.com/docs/agents/connect-over-mcp) [The tools Every tool the MCP server offers, the envelope each answer travels in, and the caveats to pass on. ](https://yore.steddle.com/docs/agents/the-tools) [The yore command The same answers in a terminal, and a check of an export that needs no connection to Yore. ](https://yore.steddle.com/docs/agents/the-command) [Tokens A bearer token for the yore command, or for a client that does not sign in with OAuth. ](https://yore.steddle.com/docs/agents/tokens) --- # https://yore.steddle.com/docs/agents/connect-over-mcp [ Docs ](https://yore.steddle.com/docs) [ Agents ](https://yore.steddle.com/docs/agents) Connect over MCP ================ The server's address, connecting Claude, the consent screen, limits and disconnecting. 04 Agents ------ Article 1 of 4 Yore is an MCP server. Connect it to Claude or another MCP client once, and your assistant can do what the site does: make a plan, choose its pages, start a run, compare versions, trace a sentence and make an export. It acts as you, on your plans. The address ----------- The server answers at one URL, over streamable HTTP: ``` https://yore.steddle.com/mcp ``` It needs a signed-in account. There are two ways in: OAuth, which is what connectors in Claude and ChatGPT use, and a [token](https://yore.steddle.com/docs/agents/tokens) for a client that doesn't do OAuth. Connect Claude -------------- In Claude, add a custom connector and paste the address above. In Claude Code, run: ``` claude mcp add --transport http yore https://yore.steddle.com/mcp ``` Your client registers itself with Yore and sends you to sign in with your Steddle account. Then you see a consent screen that names the client asking for access, the host it receives that access at, and what it may do. Approve it and the client gets a token with one scope, `mcp:use`. Other clients ------------- Yore publishes its OAuth details where MCP clients look for them, at `/.well-known/oauth-protected-resource` and `/.well-known/oauth-authorization-server`, and accepts dynamic client registration. A client may only register a redirect address on `claude.ai`, `claude.com`, `chatgpt.com` or `localhost`. Any other client can use a [token](https://yore.steddle.com/docs/agents/tokens). What your assistant can do -------------------------- Every tool is scoped to your account: your plans, their pages, their exports and their share links. Nobody else's. [The tools](https://yore.steddle.com/docs/agents/the-tools) lists each one. Three things to know up front: - **A run spends a shared budget.** Starting a run makes Yore fetch from the web archive, at about 40 requests a minute for every plan together. The server tells your assistant to read the coverage first, which states the number of requests and the wait. - **A share link opens archived text to whoever holds it.** The server tells your assistant to make one only when you ask. - **Deleting a plan can't be undone.** Its exports and share links go with it. Limits ------ The server allows 120 requests per minute per account, and one address can register ten clients an hour. Yore never receives your conversation with the assistant, only the tool calls it makes. Disconnect an app ----------------- The **Agents** page lists every app you connected, with the host it receives its access at. Choose **Disconnect** and it loses access straight away: its access and refresh tokens are revoked, so it can't renew them. To use it again, connect it again. Checked against the code on 1 October 2026. [ The tools ](https://yore.steddle.com/docs/agents/the-tools) --- # https://yore.steddle.com/docs/agents/the-tools [ Docs ](https://yore.steddle.com/docs) [ Agents ](https://yore.steddle.com/docs/agents) The tools ========= Every tool the MCP server offers, the envelope each answer travels in, and the caveats to pass on. 04 Agents ------ Article 2 of 4 The MCP server offers 31 tools. Each one is a route of Yore's API under another name, so a tool answers exactly what the site and the [yore command](https://yore.steddle.com/docs/agents/the-command) get. This page lists them as the server describes them to an assistant. The envelope ------------ Every answer is one JSON object: ``` {"yore": 1, "data": { }, "caveats": [ ]} ``` - `yore` is the contract's number. It goes up when a consumer would have to change. - `data` holds the answer. - `caveats` states the limits on what the answer supports: that a version runs from its first capture to its last, that the archive didn't look in between. An assistant should pass each one on with the answer it belongs to. A failure carries `error` in place of `data`, with a `kind`, a finer `code` and a `message`: ``` {"yore": 1, "error": {"kind": "not_found", "code": "not_fetched", "message": "no version [9]"}} ``` | Kind | Means | |---|---| | `usage` | The request is wrong as asked. Asking again fails the same way. | | `auth` | No account, or not this account's. | | `not_found` | The thing doesn't exist as asked. A version that isn't fetched yet answers with the code `not_fetched`. | | `throttled` | Too many requests. `retry_after` says when to ask again. | | `archive` | The Internet Archive refused or didn't answer. | | `internal` | Yore failed. | The order of a plan ------------------- A plan goes through `plan_create`, `plan_tree` to see what the site holds, `plan_update` to set paths and languages, `plan_read` to read the archive's index, `plan_pages` and `plan_tick` to choose pages, `plan_coverage` to see what a run costs, and `plan_run`. Reading and running happen in the background, so an assistant polls `plan_show` and `plan_coverage`. Plans ----- ### `status` Who is connected, how many plans the account holds and its caps. Call it first. ### `plan_list` Every plan of the account: its website, its rules, its state and how many pages it holds. ### `plan_create` Make a plan for a website. Yore reads the site's sitemaps, today's and the archive's older ones, so plan\_tree can show what the site holds; the plan is `reading` until that is done. Name the paths and languages now or later with plan\_update, then call plan\_read. Takes `hosts` (required), `name`, `paths`, `locales`, `from`, `until`, `density`. ### `plan_show` One plan: its rules, its state (draft, reading, ready, indexing, indexed, running, paused, done, failed) and its counts. While it is busy, `progress` states the step it is on, how much of that is done, and the minutes left at the archive's pace where that sets the wait. Takes `plan` (required). ### `plan_update` Change a plan's rules. On a plan whose index was read, a path or language taken away takes its pages off the plan at once, and one added is read from the archive's index in the background: the plan is `indexing` until it is `indexed`, and its other pages stay. A plan never read needs plan\_read. Takes `plan` (required), `name`, `paths`, `locales`, `from`, `until`, `density`. ### `plan_delete` Delete a plan. The captures Yore fetched stay in its shared cache; the plan, its ticks, its exports and its share links go, and that cannot be undone. Takes `plan` (required). ### `plan_tree` What the website holds under one path, as Yore knows it from the sitemaps and the index: each child segment with how many pages lie under it, and the languages the site speaks. Use it to choose paths. Takes `plan` (required), `host`, `under`, `locale`. ### `plan_read` Read the archive's index for the plan's rules: every page its paths name, including pages the site has since removed, and every capture of each. Runs in the background; the plan is `indexing` until it is `indexed`. Costs one request or a few per path and language, and a path read in the last day is not read again. On a plan already read, this is how to learn what the archive captured since. Takes `plan` (required). ### `plan_pages` The pages on a plan, each with whether it is ticked, how many captures and versions it has, its first and last capture, and its removal if the archive shows one. Takes `plan` (required), `under`, `locale`, `ticked`, `removed`, `q`, `sort`, `limit`, `page`. ### `plan_tick` Tick pages in or out of a plan. Only ticked pages are fetched, compared and exported. Name the pages by id, by the start of their path, by language, by a part of their address, those removed or redirected, or all of them; filters narrow each other. Takes `plan` (required), `ticked` (required), `pages`, `under`, `locale`, `q`, `removed`, `all`. ### `plan_coverage` What running the plan costs and how far it is: ticked pages, captures in the window, distinct versions to read, how many are already fetched, how many requests remain, the minutes that takes at the archive's pace, and captures per year. Read it before plan\_run. Takes `plan` (required). ### `plan_run` Start fetching the plan's captures from the web archive. Yore fetches each distinct version once, at the archive's pace, taking turns with other plans; then it reads the text, builds the versions and fetches the images. Runs in the background: plan\_coverage shows progress. Takes `plan` (required). ### `plan_pause` Stop fetching for a plan. plan\_run resumes it. Takes `plan` (required). Reading ------- ### `page_show` One page: its versions in order, each from its first capture to its last with how many captures prove it, its removal, and its captures per year. Takes `plan` (required), `page` (required). ### `version_show` One version of a page: its text in sections, the whole text with nothing set aside, the capture it comes from (snapshot URL, UTC time, status, the archive's digest and the SHA-256 of the bytes Yore froze), and its images, each with the date of its own capture. Takes `plan` (required), `page` (required), `position` (required). ### `compare` Two versions of one page set against each other, section by section: which sections stayed, changed, came or went, with the text before and after, and how many words were added and removed. Takes `plan` (required), `page` (required), `from` (required), `to` (required), `whole`. ### `phrase` The life of a sentence: on which pages it stood, from which capture until which, how many captures prove it, the longest stretch the archive did not look, and the first capture without it. Letter case and typographic quotes are ignored. Quote the sentence as the page prints it. Takes `plan` (required), `q` (required), `page`. ### `changes` What changed across the plan, by month, newest first: pages that first appeared, pages whose text changed, and pages that were removed or redirected. Takes `plan` (required), `from`, `until`. ### `languages` The same page in the site's other languages on one date, each as its own latest capture on or before that date, in sections. Pages are paired by the hreflang links the page itself carries, or by the same path under another language. Takes `plan` (required), `page` (required), `at` (required). Evidence -------- ### `export_make` Make an export of the plan: one zip with every ticked page, each capture the archive holds in the window, each version, the bytes, the texts and the images, and a manifest with the SHA-256 of every file. Built in the background: export\_list shows when it is `ready`, with the manifest's own SHA-256. The file is downloaded on the site or with `yore export download`. Takes `plan` (required). ### `export_list` The plan's exports, newest first, each with its state, its size and its manifest's SHA-256. Takes `plan` (required). ### `exhibit_make` Print one comparison as an exhibit: a PDF with the two captures, their addresses in the web archive, their hashes, and every changed section word by word. Answers the PDF's SHA-256; the file is downloaded on the site or with `yore exhibit`. Takes `plan` (required), `page` (required), `from` (required), `to` (required), `whole`. ### `share_make` Make a link that shows one comparison, read-only, to whoever holds it. Only make one when the user asks to share: the link opens archived text to anyone. Takes `plan` (required), `page` (required), `from` (required), `to` (required), `whole`. ### `share_list` The plan's share links, each with its address, what it shows and whether it was revoked. Takes `plan` (required). ### `share_revoke` Revoke a share link. It closes for everyone who holds it. Takes `plan` (required), `token` (required). ### `verify` Whether Yore issued a file with this SHA-256, an export's manifest.json or an exhibit's PDF, and when. It says nothing of what the file holds. Takes `sha256` (required). Going forward ------------- ### `watch_set` Start or stop watching pages. A watched page is checked once a day with Yore's own client: a change is captured and frozen that day, and the Internet Archive is asked to capture it too. Takes `plan` (required), `pages` (required), `watched` (required). ### `watch_list` The pages the plan watches, each with its last check: when, what the site answered, and whether the page was captured, unchanged, changed, removed or blocked. Takes `plan` (required). ### `watch_check` Check one page now with Yore's own client. One request to the site, at most once a minute per page. Takes `plan` (required), `page` (required). ### `watch_log` Every check of a page, newest first: the ledger only grows. Takes `plan` (required), `page` (required). Other ----- ### `plan_resume` Hand a busy plan that went quiet to a worker again. plan\_show says `quiet` when a plan is reading, indexing or running and Yore has not heard from its job for 15 minutes: a worker stopped mid-way leaves it so. What was already read is kept. Refused while the plan is still at work. Takes `plan` (required). Checked against the code on 1 October 2026. [ Connect over MCP ](https://yore.steddle.com/docs/agents/connect-over-mcp) [ The yore command ](https://yore.steddle.com/docs/agents/the-command) --- # https://yore.steddle.com/docs/agents/the-command [ Docs ](https://yore.steddle.com/docs) [ Agents ](https://yore.steddle.com/docs/agents) The yore command ================ The same answers in a terminal, and a check of an export that needs no connection to Yore. 04 Agents ------ Article 3 of 4 `yore` is Yore in a terminal. It asks the same API the site and the [MCP server](https://yore.steddle.com/docs/agents/connect-over-mcp) ask, so it gives the same answers, and it checks an export on its own, offline. Install ------- The command is one binary, built from its source with Rust's Cargo. In a checkout of the source: ``` cargo build --release ln -sf "$PWD/target/release/yore" ~/.local/bin/yore ``` Sign in ------- Make a [token](https://yore.steddle.com/docs/agents/tokens) on the **Agents** page, then: ``` yore login --url https://yore.steddle.com ``` The command asks for the token, keeps it in `~/.yore/config.json`, readable by you alone, and prints who is connected. `YORE_TOKEN` and `YORE_URL` in the environment take the place of the file. ``` yore status ``` A plan ------ ``` yore plan create --host tesla.com --host teslamotors.com --from 2014-01-01 --until 2024-12-31 yore plan list yore plan tree --under /model3 yore plan update --path / --path "/model3*" --locale nl_nl --locale "" --density monthly yore plan read yore plan pages --sort captures yore plan untick --under /model3/design yore plan coverage yore plan run ``` `plan show`, `plan pause`, `plan tick`, `plan changes` and `plan delete` do what they say. A plan is named by its id, as `plan list` prints it. [Make a plan](https://yore.steddle.com/docs/getting-started/make-a-plan) explains each step. A page ------ ``` yore page show yore page version 12 yore page compare 11 12 yore page compare 11 12 --whole yore page languages --at 2019-03-01 yore phrase "full self-driving hardware" ``` A page is named by its id, as `plan pages` prints it, and a version by its position, as `page show` prints it. `page compare` prints each changed section with the words that went as `[-word-]` and the words that came as `{+word+}`. Evidence -------- ``` yore export make yore export list yore export download -o export.zip yore exhibit 11 12 -o exhibit.pdf yore share make 11 12 yore share list yore share revoke yore blob ``` `exhibit` checks the PDF it downloads against the SHA-256 Yore states for it. `blob` writes the bytes a hash names to standard output and refuses them if they don't hash to that name, so `yore blob | shasum -a 256` prints the hash you asked for. Going forward ------------- ``` yore watch add --page yore watch list yore watch check yore watch log yore watch remove --page ``` Verify an export, offline ------------------------- ``` yore verify export.zip ``` `verify` needs no token and makes no request. It reads the export's `manifest.json`, prints the manifest's own SHA-256, and checks every file the manifest lists: that it's there, that it hashes to its name, and that its size is as stated. For every capture it recomputes the Internet Archive's digest and compares it with what the manifest says. A file the manifest doesn't list fails the check too. It takes the zip, or a directory the zip was unpacked into. With `--online` it also asks Yore whether it issued that manifest, and when. For a script ------------ `--json` prints the service's answer as it was sent: the [envelope](https://yore.steddle.com/docs/agents/the-tools#the-envelope), byte for byte. A failure prints its envelope too, with the sentence for a human on standard error. ``` yore plan coverage --json ``` Exit codes ---------- | Code | Means | |---|---| | 0 | It worked. | | 1 | The command or the request was wrong as asked. | | 2 | Not found. | | 3 | The network: Yore couldn't be reached. | | 4 | Yore refused or failed: no valid token, too many requests, the archive didn't answer. | | 5 | Something on this machine: a file that can't be read or written. | | 6 | An export that doesn't verify. | Checked against the code on 1 October 2026. [ The tools ](https://yore.steddle.com/docs/agents/the-tools) [ Tokens ](https://yore.steddle.com/docs/agents/tokens) --- # https://yore.steddle.com/docs/agents/tokens [ Docs ](https://yore.steddle.com/docs) [ Agents ](https://yore.steddle.com/docs/agents) Tokens ====== A bearer token for the yore command, or for a client that does not sign in with OAuth. 04 Agents ------ Article 4 of 4 A token is a way in without the sign-in screen. The [yore command](https://yore.steddle.com/docs/agents/the-command) uses one, and so can an MCP client or a script of your own that doesn't sign in with OAuth. Create a token -------------- 1. Sign in and open **Agents**. 2. Under **Tokens**, choose **Create token** and name it after where it will live, like *yore on my laptop*. 3. Copy the token right away. It's shown once: Yore only keeps a hash of it. A token lasts one year from the day you create it. Use a token ----------- For the command: ``` yore login ``` For anything else, send it in the `Authorization` header. The same token opens the MCP server and the API the site and the command ask: ``` curl -H "Authorization: Bearer YOUR_TOKEN" -H "Accept: application/json" https://yore.steddle.com/api/v1 ``` The limit is the same as over OAuth: 120 requests per minute per account. Keep it safe ------------ A token acts as you. Whoever holds it can read your plans, start a run, make a share link and delete a plan. So: - keep a token out of code you share and out of repositories; - give each machine or client its own token, so you can cut one off without the others; - revoke a token you don't use. Revoke a token -------------- The **Agents** page lists every token with when it was created and when it was last used. Press **Revoke** next to one and confirm. It stops working at once. Checked against the code on 1 October 2026. [ The yore command ](https://yore.steddle.com/docs/agents/the-command)