AI decisions (EU AI Act)
When an AI system decides, or proposes a decision, about a person — an admission, a permit, a credit limit, a shortlist — someone will later ask what it decided, on what, with which model, and whether a person checked it. HardState keeps that record in your institution’s own HardState Log: each decision is a signed event, chained to the previous one and anchored to Bitcoin. Nobody can change or delete one afterwards without it showing, including you and us.
What the EU AI Act asks, and what the record gives
Section titled “What the EU AI Act asks, and what the record gives”For high-risk systems (Annex III: education, employment, credit and insurance, essential public services, critical infrastructure, justice and biometrics), the obligations apply from 2 December 2027.
| The Act asks | The HardState record gives |
|---|---|
| Automatic logging over the system’s lifetime (art. 12) | One signed ai.decision per decision, with system, model, version and configuration hash; agent runs sealed step by step |
| Keeping the logs at least six months (arts. 19 and 26(6)) | Records anchored to Bitcoin that cannot be quietly rewritten, plus a heartbeat that shows when the logging stopped |
| Human oversight (arts. 14 and 26) | ai.review signed with the reviewer’s own passkey: confirmed, overridden or rejected, with the time |
| An explanation for the person affected (art. 86) | A receipt for that person, with a link to your explanation and a way to check the inputs and outputs they were given |
The four records
Section titled “The four records”| Type | Signed by | Public facts (public) |
Committed, private (docs) |
|---|---|---|---|
ai.decision |
the AI system | system, model, version, config (hash of its configuration), outcome, oversight (required | none), score?, explanation? (a link) |
AI input, AI output, other material |
ai.run |
the AI system | system, model, version, steps, root (one seal over all the steps), outcome |
each step’s input and output |
ai.review |
a person | decision (the decision’s hash), action (confirm | override | reject), outcome? |
the reason, if given |
ai.heartbeat |
the AI system | system, model, version, every (seconds), decisions, runs, failures, since?, instance, digest |
— |
Contents never enter the log. Inputs, outputs, prompts and reasons are committed with a salt: you keep them and
their salts, and hand them to whoever has a right to check them. The log publishes only the facts you choose and
hashes no one can reverse. Never put names or personal data in public fields: use your file or application number as
the case.
The heartbeat is what lets the record claim to be complete. The system signs one at a regular interval, and if it stops recording or a record goes missing, the gap shows.
A review is a person’s act. ai.review is signed with the reviewer’s own key (a passkey, or a session they
opened), never with the AI system’s key. The API refuses a review signed by a system key.
Set it up
Section titled “Set it up”Everything below is the same HTTP flow as any HardState record: prepare → sign → submit, in any language that can make an HTTP request and an Ed25519 signature. See API integration for the basics.
-
Connect the agent in the console. In the AI systems tab, Connect an agent asks for its name, its department and whether a person must review its decisions. The browser generates the agent’s Ed25519 key and hands it over once as a
.envfile (HARDSTATE_API,HARDSTATE_ISSUER,HARDSTATE_AGENT_ID,HARDSTATE_AGENT_KEY); HardState never receives it. An admin authorizes it with one passkey signature as a system key limited toai.decision,ai.runandai.heartbeat. If it lives in a department, that department’s types must allow them.If the agent should make its own key, so the private key never leaves it, generate an Ed25519 key pair and paste its request link in the same wizard (My agent has its own key):
https://app.hardstate.net/console?device=<base64url(JSON)>JSON = { "v": 1, "label": "Admissions screening (AI)", "publicKey": "<SPKI DER, base64url>","types": ["ai.decision", "ai.run", "ai.heartbeat"] } -
Record each decision where your system makes it. Commit the input and the output with a fresh salt each, put the commitments in
docs, and the public facts inpublic:bytes = the content as UTF-8 (JSON: its RFC 8785 canonical form)salt = 32 random bytes (keep it)commitment = SHA-256("hardstate/doc/v1" ‖ salt ‖ SHA-256(bytes))config = hex(SHA-256(canonical(configuration)))const sha256hex = async (s: string) => Buffer.from(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(s))).toString("hex");const commit = async (label: string, content: string) => {const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content));const salt = crypto.getRandomValues(new Uint8Array(32));const pre = new Uint8Array([...new TextEncoder().encode("hardstate/doc/v1"), ...salt, ...new Uint8Array(digest)]);return { label, salt: Buffer.from(salt).toString("hex"),commitment: Buffer.from(await crypto.subtle.digest("SHA-256", pre)).toString("hex") };};// A flat object with sorted keys is already canonical JSON (RFC 8785).const config = await sha256hex(JSON.stringify({ rubric: "v3", temperature: 0 }));const input = await commit("AI input", JSON.stringify(application));const output = await commit("AI output", modelAnswer);// record(): POST /v1/events/prepare with { issuer, type, case, public, docs, actor }, sign .hash, POST /v1/eventsconst r = await record({issuer: "example-university", type: "ai.decision", case: "ADM-2027-00412", // your reference, never a namepublic: { system: "Admissions screening", model: "your-model", version: "2026-11", config,outcome: "shortlist", oversight: "required", score: 0.82,explanation: "https://example.edu/admissions/how-we-decide" },docs: [input, output].map(({ label, commitment }) => ({ label, commitment })),});keep([input, output]); // the salts: without them nobody can check the contentsnotify(applicant, `${r.receipt}#k=${[input, output].map((c) => `${c.commitment.slice(0, 16)}.${c.salt}`).join(",")}`);The person affected gets the receipt with the salts of their own input and output after the
#, so they can check them; browsers never send that part to a server. -
Beat from a timer, hourly by default: an
ai.heartbeatwithevery(seconds between beats), how manydecisions,runsandfailuresthis process recorded since its previous beat,since(theseqof that previous beat),instance(a short id for this running process, so replicas and restarts never look like gaps) anddigest, a running hash over this process’s records since its previous beat, as the Receipt Format defines it. With it, anyone can check that the log holds exactly the records the process vouched for. -
Review. The people who oversee the system confirm, override or reject pending decisions in the AI systems tab’s review queue, signing with their own passkey (or a one-hour review session: one prompt for many). Your own system can also record the review, signed with a session of the reviewer’s: an
ai.reviewwhosepublicis{ decision, action, outcome? }.
Agents that take many steps
Section titled “Agents that take many steps”When a decision takes several steps (model calls, tool calls, retrievals, rules), the whole run can be sealed as one
ai.run record, so a busy agent does not spend your plan’s records. Each step stays provable on its own, without
revealing the others, and a run that fails is recorded as failed, with a public category and never the message.
For each decision you can keep an evidence package: everything needed to rebuild the decision later and check it against the log, for your own audit, a supervisor or a court. Dropped on app.hardstate.net/verify, it reads like a report for someone who is not an engineer: what the agent did, whether it went well, whether a person reviewed it, what information it looked at, and which step failed and why. The technical detail is one click below.
Runs and evidence packages are written with HardState’s agent SDK (TypeScript), which we provide to customers. Write to hello@hardstate.net to get it.
What each person sees
Section titled “What each person sees”- Your institution and its auditor — the console’s AI systems tab: decisions per system, the share reviewed by a person, overrides, decisions still waiting for review, and every gap the heartbeat shows; and, from your evidence packages, the process behind any single decision.
- The person affected — a receipt that says the decision was made by an AI system, which one, whether a person reviewed it, and where to read the explanation. With the keys in their link they can check that their input and output are exactly the ones recorded.
- Anyone — the same verification as every HardState record, in the browser and against Bitcoin, without trusting you or us.
The ai.* records are part of the HardState API: any system can write them over HTTP.
HardState is a Zevlat Intelligence venture. © 2026 Zevlat Intelligence.