How Assert works

What a thesis is

A thesis on Assert has four required parts: a title, the claim itself, the reasoning behind it, and a prediction. Sources, a deadline and a visual are optional. The split matters: the claim is what you assert, the reasoning is why, and the prediction is the part that can later be shown right or wrong.

Write the prediction so that it could fail. A thesis nobody could ever call incorrect is not a thesis, and it will read that way on your profile.

Drafts

A draft is private to you. It is saved as you write, it is never listed on Explore, and the API returns a 404 rather than a 403 to anyone else who asks for it, so its existence is not disclosed either.

Drafts can be changed freely and deleted outright. Nothing about a draft is permanent, which is the whole point of the distinction.

What publishing seals

Publishing is one-way. The server validates the thesis, builds a canonical representation of it, computes a SHA-256 over those exact bytes, stores the snapshot and the hash, stamps the time and moves the thesis to active.

From that moment the title, claim, reasoning, prediction and sources are read-only on every code path, not just in the interface. The endpoint that saves draft fields refuses a published thesis, and so does the one that adds or removes sources.

The visual is deliberately outside that seal. It is presentation rather than claim, it can still be changed, and the record page says so instead of leaving you to assume the hash covers it.

The content hash

The canonical representation is JSON with keys sorted at every level and no incidental whitespace, so the same content always produces the same bytes. It carries a version string, which is itself hashed, so a future change to the format cannot silently alter an old hash.

Every thesis has a record page that prints those exact bytes next to the hash, with the command to recompute it. If the two disagree, the record has changed.

This is an offchain cryptographic record. Nothing is anchored to a blockchain and there is no third-party timestamp, so what it proves is that the printed text is what was published and that Assert has held this hash since then. It rests on Assert keeping it honestly, and saying otherwise would be a lie.

Updates

Your view will move, and the product expects it to. New information is published as an update: timestamped, attributed, and appended below the original rather than folded into it.

Updates cannot be edited or deleted either. The history is the record.

Resolution, and who decides

An author resolves their own thesis as correct, partially correct, incorrect or unresolved, and has to write an explanation. It can be done once.

Assert runs no independent verification of any kind. Every outcome is labelled author reported wherever it appears, including on profiles and in the API. Treat a hit rate here as a claim its author is making in public, not as an audited figure.

A hit rate counts a partially correct call as half. Open theses do not count toward it at all, so leaving a losing thesis unresolved does not protect a record; it just leaves it open.

How a record is scored

Two numbers, and both are arithmetic you can do yourself from the public rows. The hit rate is the plain one: each resolved thesis scores 1 if its author called it correct, 0.5 if partially correct and 0 if incorrect, and the total is divided by how many resolved. A thesis the author marked unresolved is excluded from both numbers and counted separately, because an answer that never arrived is not a wrong call and it is not a right one.

The second number weights a call by how early it was made. A thesis published a year or more before its own deadline counts double; one published the day before the deadline counts once; everything between scales linearly across that year. The weight multiplies both the credit and the divisor, so being early does not inflate a record by itself. It only makes a correct early call worth more than a correct late one.

An open thesis never counts toward either figure. Leaving a losing call unresolved does not protect a record, it just leaves it open, and the open count sits beside the rest. An author with nothing resolved has no score at all rather than a zero, because a zero reads as a bad record rather than an absent one.

No model is involved and nothing is hidden. The formula lives in one file, the same function produces the figure on a profile and the one in the API, and a thesis with no deadline simply takes the base weight.

Who verifies an outcome

By default, nobody. A resolution is the author's own verdict, and it is labelled that way everywhere it appears, including in the API, where the payload carries a field saying so.

Anyone signed in who is not the author can file a verification claim against a published thesis: a state of verified or disputed, the outcome the evidence supports, and a link to the source it rests on. A claim with no source is refused, by the code and by a constraint in the database underneath it. The thesis's own author cannot file one, which is the entire point of keeping the two apart.

A thesis reads as unverified until somebody does that, and a single dispute makes it read as disputed even if other claims agree, because 'some sources disagree' is the honest summary of that situation. Assert runs no automatic checker. Most theses here are about things no feed can settle, and a checker that claimed otherwise would be inventing certainty.

Theses published elsewhere

A thesis can record that it first appeared somewhere else: a URL, and the date the author says it went up there. That claim is stored apart from the thesis, is never part of the canonical snapshot, and is shown as the author's own statement wherever it appears.

Assert can witness exactly one date, which is when the thesis arrived here and was hashed. It cannot confirm that a post really went up last March, and it does not pretend to. The published timestamp and the content hash keep meaning precisely what they always meant, and an imported date sits beside them marked as unverified.

The public API

Everything published on Assert is readable without an account, at /api/v1/theses, /api/v1/theses/{slug} and /api/v1/authors/{username}. The list endpoints page with limit and offset and report a total, slugs are stable from publication onward, and the filters are the same ones Explore uses.

It is read-only and it reaches nothing private. A draft has no slug and is excluded by every query behind it, and each response is an explicit list of fields rather than a database row, so a column added later cannot begin leaking through it. There is no account id, email or wallet address anywhere in a response.

Anchoring a proof to Solana

The hash on this page is Assert's own record, and it rests on Assert keeping it honestly. Anchoring removes that dependence for anybody who wants it removed: an author can write a short proof string into one memo transaction on a public chain, and from then on the timestamp is the network's rather than ours.

The proof is a versioned string holding three things: the thesis's id, its content hash and its publication time. No title, no claim, no reasoning, no prediction, no sources, no username, no wallet address and no email go onchain. A reader of the chain learns a hash, an opaque id and a time, which is exactly enough to check the proof and nothing more.

It is one memo instruction. Nothing is transferred, no token exists and the only cost is the network's own fee, paid by whoever signs. Publishing never depends on it: a refused signature or a failed broadcast leaves the published thesis exactly as it was, and a thesis that is never anchored is not a lesser record.

Assert reads the transaction back off the chain before believing any of it. A signature from a browser is treated as a hint, not evidence: the memo found on chain has to equal the sealed proof exactly, so a transaction for a different thesis, a different hash or a different cluster is refused and nothing is marked anchored. Submitting the same one twice changes nothing.

What this proves is that the proof existed and was anchored at that slot. It does not prove the thesis is correct, and no chain can. Today anchoring runs on devnet only; mainnet is disabled in the code itself rather than behind a setting.

Visuals

A thesis can carry a mark, which is a figure drawn from its own id. It is deterministic geometry: the same thesis always produces the same mark, and no image model is involved at any point.

You can also upload your own image. It is re-encoded on the server, which strips metadata and rejects anything that is not actually an image.

No image model is connected to Assert, and nothing here is described as AI generated, because nothing here is.

Accounts and privacy

A wallet is the whole account. You connect a Solana wallet you already have and prove you control it, and Privy handles that step. Assert never sees a password, creates no wallet on your behalf and holds no key for you.

Your wallet address is never shown on a thesis or returned by any public endpoint. Your username is, and because it is written into the canonical snapshot of everything you publish, it is chosen once and then fixed.

Connecting is the only thing your wallet is ever asked to do. Assert requests no transaction, reads no balance, and holds no token. There is no payment anywhere in it, and no embedded wallet is created for you.