Skip to content
HHISTOREVIDENCE LAYER
Patent pending

The evidence layer for autonomous AI.

Histor is an independent witness for AI agents. When an agent reads from any HTTPS server, Histor co-signs a receipt of exactly what that server sent. The agent’s own operator can’t forge it or edit it later, and anyone can check it offline.

agents that can prove what they saw

agent → TLS session → witness co-signs → receipt → anyone verifies

Any HTTPS server
Nothing to install on it
~10 ms offline check

Histor receipt

What the server sent

recorded run
Houston Hobby · KHOU
valid
server
api.weather.gov
request
GET /stations/KHOU/…/latest
session
2026-10-21 16:45:29 UTC
sky
Cloudy
temp
26 °C
wind
9.252 km/h
witness
02ef3dd7…6740 · secp256k1
receipt
sha256:43ed328b…4e03
rest of response: hiddenoffline check

verification path

certificate → commitment → witness

web PKIcommitmentwitness key

$ histor verify --trust 02ef3dd7…6740 \

  --receipt-file genuine.json

valid: true · exit 0

Who Histor is for

Agent builders

Your agent hands another agent, a customer or an auditor a receipt for what an API said. They check it offline and act on it, without trusting you.

Insurers and MGAs

AI-liability cover runs on agent logs the insured writes. A Histor receipt is evidence the insured did not write and cannot edit.

Risk and platform teams

Agents that move money or change records leave a trail your own staff cannot rewrite, checkable by anyone with the witness key.

The gap

An agent’s log is its operator’s word.

Agents now move money, file records and act on data they fetched. When something goes wrong, the only record of what the agent saw is a log the operator wrote, and the operator can write anything into it. API providers don’t sign their responses, so there is nothing to check that log against.

An agent log today

  • Written by the operator, after the fact.
  • Editable by anyone with access to the logs.
  • Signing it later stops backdating, but the false entry was made at the start.
  • Insurers, auditors and other agents take it on trust.

A Histor receipt

  • Co-signed during the session by a witness the operator doesn’t control.
  • Fixed bytes. Change one and verification fails.
  • Names the server through its public web certificate.
  • Checked offline in about 10 ms, with no call to Histor.

How it works

One TLS session, relayed through a witness.

Histor is built on TLSNotary, an open-source protocol for proving what a TLS server sent. The verifier trusts two things: the witness’s public key, and the same public certificate authorities your browser trusts.

01

Connect

The agent opens an ordinary TLS session to any HTTPS server: a weather feed, an FX rate API, a bank. Nothing is installed on that server.

02

Relay

The Histor witness dials the server itself and relays the encrypted TLS records both ways, recording every byte. It holds no key. The agent keeps the session keys and its credentials.

03

Co-sign

The agent proves in zero knowledge that the records the witness relayed decrypt under keys from that handshake. The witness then signs a commitment to those exact bytes, with the session time from its own clock.

04

Verify offline

Anyone checks the receipt in about 10 ms with no network call. The agent can disclose single fields, such as one exchange rate, and keep the rest of the response hidden.

What the witness never sees

The session keys, the plaintext and the agent’s credentials. It checks a zero-knowledge proof over the encrypted records and signs commitments to them.

What the witness sees

Which server the agent called, when, and the size and timing of every encrypted record. It dials the server itself, so the receipt also rests on that network path being clean.

Working proofs

We tried to forge it. Here is what the verifier said.

Both tests ran against live public APIs. The outputs below come from the recorded runs.

Weather forge test

3 of 3 as expected

The operator wants a receipt saying Houston had hurricane-force wind. Three tries, through a witness in proxy mode.

What the operator tries

Nothing. The agent reads the live observation for Houston Hobby Airport (KHOU) from api.weather.gov through the witness.

Verified
Verifier output
recorded 2026-10-21 16:45 UTC
$ histor verify --trust 02ef3dd7…6740 --expect-server api.weather.gov \
    --receipt-file genuine.json
valid:    true
server:   api.weather.gov
time:     2026-10-21 16:45:29 UTC
fields:   station KHOU · observed 16:30 UTC · Cloudy
          temperature 26 °C · wind 9.252 km/h
exit 0

Trimmed from the run log, not edited. TLSNotary v0.1.0-alpha.15, proxy mode, TLS 1.2.

Two-agent payment demo

1 paid · 4 refused

Agent A quotes the USD→EUR rate from api.frankfurter.dev (ECB reference rates). Agent B pays a €10,000 invoice in dollars at that rate. Every message between them passes through a relay that tries to cheat. Agent B acts only on a value inside a valid receipt, from the right server, for the right request, less than ten minutes old.

RoundThe relayAgent B
1Forwards the message unchangedComputes the payment at the witnessed rate
2Changes the rate, leaves the receiptRefuses: the claim does not match the receipt
3Changes the rate and edits the receipt to matchRefuses: the receipt fails verification
4Swaps in a genuine receipt for USD→GBPRefuses: the receipt answers a different request
5Strips the receiptRefuses: unwitnessed claim

The agents are scripted MCP clients, not language models, so runs repeat exactly. No money moved; agent B computes the payment.

~10 ms

to verify a receipt, offline

0.7–2.7 s

per witnessed call, proxy mode

2.3–4.0 MB

between agent and witness, per call

0

software installed on the server

Measured on one machine with the witness running locally. A remote witness has not been measured yet.

Limits

What a receipt does not prove.

A receipt proves what a named server sent, and when. Read it as exactly that.

It does not prove

  • That the server told the truth. A receipt shows what api.weather.gov said, not the weather.
  • Anything about a server the operator controls. That receipt is still the operator’s word, now fixed in time and bytes.
  • That the agent sent every action through the witness. That takes credential custody or egress control.
  • Independence, when one party runs both the agent side and the witness. High-value receipts should carry more than one witness.
  • That nobody took over the network path between the witness and the server. An agent that can do that can let the real handshake through, then feed the witness bytes it chose.
  • That the content is safe to act on. A genuine page can still carry a prompt injection.

Engine limits today: TLS 1.2 only (TLS 1.3 is on TLSNotary’s roadmap), pre-release software, and no compressed or streamed responses.

Developers

Tools your agent already knows how to call.

Histor ships as a CLI and an MCP server, so it works in Claude Code, Cursor and any MCP client. Receipts are content-addressed: agents pass a short receipt_id instead of 15 KB of base64.

witnessed_fetch(url, fields?, mode?)

GETs an https:// URL through a Histor witness. Returns the server, time, request and disclosed fields, plus a receipt_id.

verify_receipt(receipt_id | receipt, expect_server?)

Checks a receipt another agent handed you, offline. Returns what it proves, or the reason it fails.

witnessed_request(url, method, body, request_fields?)

POST, PUT, PATCH or DELETE. Credentials for the target live on the server, so the model never sees a secret. The request body is committed and stays hidden unless you disclose named fields. Off until the server’s operator switches it on.

{
  "mcpServers": {
    "histor": {
      "command": "node",
      "args": ["histor-mcp/server.mjs"],
      "env": {
        "HISTOR_WITNESS": "<witness address>",
        "HISTOR_TRUST": "<witness public key>"
      }
    }
  }
}

Private beta. The CLI and MCP server are released to pilot teams first. The CLI output is trimmed from a run on 13 November 2026.

For insurers and MGAs

Underwrite from evidence the insured didn’t write.

New AI-liability covers ask for agent logs, and today those logs are self-reported. Cyber insurers learned to price from external scans the insured couldn’t edit. A Histor receipt gives an AI-liability book the same kind of signal for agent actions.

At claim time

Check what the agent was told before it acted. The claims desk verifies the receipt itself, offline.

At underwriting

Witnessed actions as a share of all agent actions is a number the insured can’t inflate.

Narrow by design

A receipt proves what a named server sent and when. It makes no claim about whether the agent acted well.

Pricing

Free to read. Paid to act.

Free reads let receipts spread between agents. Writes, extra witnesses and dedicated capacity pay for the network.

Witnessed reads
Free
On the hosted witness, rate-limited.
Witnessed writes
2¢
Per call that changes something: POST, PUT, PATCH, DELETE.
Two-witness receipts
+1¢
For high-value actions, once a second independent operator is live.
Design-partner pilot
$10,000
60 days. Setup, 250,000 witnessed actions and an evidence report your insurer can read.
Dedicated or self-hosted witness
Talk to us
Your own witness key and capacity, with more than one witness for high-value actions.

Security

Built so you don’t have to trust us.

The verifier needs the witness’s public key and the public web certificate roots. It never calls Histor, so a receipt keeps working even if Histor is gone.

Two trust anchors

A compressed secp256k1 witness key and the public web PKI. Nothing else.

Secrets stay put

Credentials for writes live on the server. Disclosure is fail-closed: a field that contains a credential cannot be revealed.

Public targets only

The witness resolves names itself and refuses loopback, private and cloud-metadata addresses.

Open protocol

Receipts are TLSNotary presentations. Signed statements are being mapped to COSE for IETF SCITT transparency services.

Where things stand

Updated 13 November 2026
Forge-at-birth proof
Working
Runs against the live api.weather.gov feed in proxy mode. 3 of 3 rounds behave as expected.
histor CLI
Built
witness, fetch, verify. GET and writes, proxy mode, 109 unit tests passing.
MCP server
Built
stdio and Streamable HTTP. Private beta.
Hosted witness
Built, not live
Container built and tested. Its public key is published here the day it goes live.
Second, independent witness operator
Planned
Until then, hosted receipts are labeled Histor-attested.
Hardware-backed witness tier
Planned

Found a security issue? Email founder@verdict.systems with “Histor security” in the subject. The same contact is in security.txt.

Pilot access

Bring us the agent action you most need to prove.

Design-partner pilots run 60 days. We set up the witness, run your agents’ calls through it, and hand you a report your risk team or insurer can check on their own.

This form opens an email in your own mail app. Nothing is stored on this site. You can also write to founder@verdict.systems directly.

Scripts are off

The request form needs a script to open your mail app. This link opens the same email, with the questions laid out.

Email founder@verdict.systems