Bothy Uses Arweave Receipts to Make AI Assessments Independently Verifiable
- papa
- 634 reads
Bothy anchors fingerprints of AI assessments and human reviews to Arweave, letting anyone check whether a record changed after it was created.

AI can produce a cited risk assessment, but that alone doesn’t show what a reviewer saw or whether the record changed before approval. Bothy, an open-source agent, addresses that gap by anchoring fingerprints of its assessments and human reviews to Arweave. The records stay in Bothy’s systems; anyone can independently check their fingerprints against the permanent receipts.

The distinction matters in settings where a person remains responsible for acting on an AI recommendation. A winter road duty officer, for example, may need to weigh weather warnings, gritting schedules, road gradients and incident records under time pressure. Bothy brings those sources into an evidence graph, then generates a risk score, label, draft and reasoning chain with claims linked to data. A named human can approve or reject the result, with the review recorded alongside it.
The same system supports supply-chain analysis. It can produce a cited brief on the consequences of a logistics programme losing a dependency, with a named reviewer responsible for the final call. In both cases, the product’s central idea is that a useful AI record needs evidence of what was produced and what a person decided about it.
Receipts for the output and the review
Bothy creates a SHA-256 receipt when the agent generates an output and another when a human records a decision. It anchors these fingerprints to Arweave mainnet. The underlying assessment and review remain in the application; the public record contains the fingerprint used to check whether those records still match.
A production example is available as an assessment, with its corresponding Arweave receipt. The receipt was mined at block 2032288. On the case page, selecting Verify makes the browser fetch the receipt, calculate a fingerprint from the displayed record using crypto.subtle, and compare the result. That check doesn’t rely on Bothy’s server to report whether the values match.

The first receipt establishes that a particular output existed in a particular form when it was anchored. The second connects the human review to that output through a subjectDigest and generationTx, while recording the decision and its timestamp. The reviewer’s identity is represented as a hash, so it is committed to the record without being disclosed there. For supply-chain briefs, the review receipt also pins the head of the case’s hash-chained audit log.
That gives a verifier a way to check a chain of responsibility: which generated record was reviewed, what decision was recorded, and whether the linked audit log still has the same fingerprint. If someone edits the brief, draft or log later, recomputing the digest should expose the change.
Canonical data makes the check work
Getting a stable fingerprint required more than hashing a database record as-is. A straightforward sha256(JSON.stringify(assessment)) can produce mismatches after a record passes through storage. Postgres real values may return with small floating-point differences, JSONB doesn’t preserve key order, and fields such as status and decidedAt can change legitimately after the initial receipt is made.
Bothy instead builds a canonical payload from immutable fields. It sorts keys recursively and rounds scores to four decimal places. The payload includes the assessment ID, scenario, route, timestamp, score, label, confidence, causal chain, evidence, draft, engine, responsible actor and priority. The same shared module handles this process on the server and in the browser, so an independent check can reproduce the fingerprint consistently.

This approach defines exactly what the receipt covers. It also leaves a practical boundary: the fingerprint proves that the included fields match the anchored payload. It doesn’t, by itself, prove that the evidence was complete, that the assessment was sound, or that the human made the right call.
Product paths and deployment lessons
Several implementation problems changed how the feature reached users. The initial plan used a supposed Arweave testnet at testnet.arweave.dev, but its DNS didn’t resolve. The project switched to local testing with arlocal and mainnet receipts. The developer reports that a receipt of roughly 300 bytes costs a fraction of a cent and can be looked up through its Arweave transaction address.
There was also a gap between the API and the product interface. The standard /assess endpoint anchored results, but the interface’s “Run agent” action used a streaming route that didn’t. That meant users could run the agent without receiving an anchored record. Bothy’s interface now tracks the receipt through pending, anchored or failed states and displays the result in a card.
A separate production issue involved routing through Coolify’s Traefik setup. Caddy shared a network with other applications using generic service names, which sent some requests to the wrong containers and caused 502 errors. The fix was to route through unique container names and document the required Docker project name, -p bothy.
What can change, and what comes next
Bothy supports several OpenAI-compatible inference options, including Qwen through HF Inference, OpenRouter’s free tier, Nebius, other compatible endpoints and local Ollama. If those providers aren’t available, it can fall back to a deterministic scripted engine. The anchoring mechanism records the resulting output regardless of which engine generated it. That makes the receipt useful across deployment choices, while leaving model quality and provider behavior as separate questions.
A Nosana GPU deployment is planned. The agent container and nosana.json job definition are already in the repository; credits had been claimed and were pending when the project described its status. The verification flow is intended to work whether inference runs on a VPS, a Nosana node or a local machine.
Readers can run an assessment through Bothy’s watch page, check its receipt in the browser, or retrieve receipts through GET https://bothy.trustfall.xyz/api/anchors/assessment/<id>. The implementation is available in the project repository, including the canonical payload module, anchor store and browser verification component.
Bothy’s practical contribution is a checkable record at two points: when an AI produces an assessment and when a person takes responsibility for it. Whether that trail proves useful will depend on the quality of the evidence and the review process around it. The next useful test is whether teams can adopt that verification flow without adding friction to the work they already need to do.