Skip to content

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
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.

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.

  1. 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 .env file (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 to ai.decision, ai.run and ai.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"] }
  2. 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 in public:

    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/events
    const r = await record({
    issuer: "example-university", type: "ai.decision", case: "ADM-2027-00412", // your reference, never a name
    public: { 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 contents
    notify(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.

  3. Beat from a timer, hourly by default: an ai.heartbeat with every (seconds between beats), how many decisions, runs and failures this process recorded since its previous beat, since (the seq of that previous beat), instance (a short id for this running process, so replicas and restarts never look like gaps) and digest, 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.

  4. 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.review whose public is { decision, action, outcome? }.

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.

  • 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.