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.
Histor receipt
What the server sent
- 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
verification path
certificate → commitment → witness
$ 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.
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.
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.
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.
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 expectedThe 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.
$ 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 0Trimmed from the run log, not edited. TLSNotary v0.1.0-alpha.15, proxy mode, TLS 1.2.
Two-agent payment demo
1 paid · 4 refusedAgent 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.
| Round | The relay | Agent B |
|---|---|---|
| 1 | Forwards the message unchanged | Computes the payment at the witnessed rate |
| 2 | Changes the rate, leaves the receipt | Refuses: the claim does not match the receipt |
| 3 | Changes the rate and edits the receipt to match | Refuses: the receipt fails verification |
| 4 | Swaps in a genuine receipt for USD→GBP | Refuses: the receipt answers a different request |
| 5 | Strips the receipt | Refuses: unwitnessed claim |
The agents are scripted MCP clients, not language models, so runs repeat exactly. No money moved; agent B computes the payment.
to verify a receipt, offline
per witnessed call, proxy mode
between agent and witness, per call
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.
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 2026Found 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