AEIIEA

Evidence should outlast the systems that produced it.

AI systems generate answers. Institutions publish decisions. Researchers and communities produce knowledge. But the evidence, methods, and judgments behind those outputs often become fragmented, inaccessible, or difficult to independently examine.

Pronounced eye-EE-AY-uh, AEIIEA is developing infrastructure to preserve those connections. Beginning with AI evaluation, we create durable, inspectable records of what systems produce, the conditions under which they operate, and the judgments made about them—so people can trace claims to their sources, independently examine the evidence, and challenge conclusions.

Our broader vision is an open, interoperable evidence layer connecting what institutions publish, what AI systems produce, and what communities know and judge—without collapsing different perspectives into a single truth.

Open the Explorer →

The Explorer

The Explorer is the first window into AEIIEA's evidence infrastructure.

Today, it opens a growing archive of structured, long-form, multi-turn AI evaluations. These are not ordinary chatbot conversations. Each session begins with a deliberately selected question, often informed by research into education, culture, bias, reasoning, or AI behavior. Models engage across successive turns while separate auditor and narrator roles assess and contextualize the exchange.

Each record carries a cryptographic commitment. The Explorer provides tools to inspect and check supported properties of those records, including portable evidence bundles that can be verified independently.

As new kinds of evidence become supported, the Explorer is intended to provide a common way to discover, inspect, verify, and connect records from different producers. It is a window into the evidence, not the authority that determines what the evidence means.

The Explorer shows one kind of evidence: records of what AI models did, audited by machines. The Judging Room begins the second: evidence about those same systems produced by people.

A parent reads two AI responses to a situation they recognize, chooses between them, and says why. Their choices, reasons, timing, the material they judged, and the framework they judged it under are written into a record. That record is then sealed and written to their own device.

The first pilot is being planned with a community partner. The aim is to create a first set of sealed judgments from participating Black parents: what they accept, what they reject, and why—judged by them rather than inferred for them.

The Judging Room

The Harness

Underneath AEIIEA is a harness we call Symposium. It seats two models on a question and lets them disagree over many turns, assigns a third model to audit the exchange, records the models and the costs, and seals the result the moment the conversation ends.

Its instruments are versioned. Every record carries the exact code commit and cryptographic fingerprints of the prompts and evaluation functions that defined the run. Known gaps in older records are disclosed rather than silently rewritten.

The seats are layered, and each sees only what is below it. The debaters see each other's turns. The auditor reads the conversation but cannot be addressed by it: its instructions are fixed, and a debater's words reach it only as the material under review. The narrator reads both the debate and the auditor's summary and speaks only to the human. The debaters hear from the auditor only in treatment runs, as a short summary placed in their context, and every such message is written into the record. Judgment can flow down into the debate; the debate can never flow up into the judgment.

That matters because a record stays inspectable after the model behind it is gone. Two of the ten models in the archive are already retired. Their records remain.

The System

AEIIEA is seven responsibilities, each with a boundary. Everything described as current is running today and can be read on the System page and explored on the Readout; the repository will expose the implementation when it opens.

  • Makes the evidence. Today that is Symposium, which seats two models on a question, lets them disagree over many turns, has a third model audit the exchange, and seals the result the moment the conversation ends. Every record carries the instrument it was made under and the code commit it names as its producer. Producing a record establishes nothing about whether its claims are true.

  • Says what a record is, for every producer: seven identity fields that may never be empty, a registered type, a schema version, a seal over the exact stored bytes, and one line in the day’s index. A record that satisfies the contract has an identity and a shape; whether what it says is true is not the contract’s business.

  • Where the records rest, and what makes “never edited” checkable. Each record is written once, its bytes hashed as stored, and one line appended to that day’s index; no line is ever changed, and every version of every object is kept. What the archive alone cannot show an outside party is that the index line itself is authentic, since the record and its line are kept in one custody.

  • Lets anyone check a record with nothing of ours. A bundle packs a record with what a check needs; a verifier reads it with the network unplugged and says pass, partial, unresolved or fail, with a reason on every check. The same checks run on the Readout, on the command line, and at Verify in your own browser, where nothing is uploaded. A pass establishes that the bytes match their commitment and that the recorded instrument agrees with the snapshot for the commit the record names. It does not say who published, when, or whether anything the record says is true.

  • Views rebuilt from named sources, for finding and counting: the day’s index files read into a short cache, the profiles computed in your browser, the Readout’s history file. Nothing general is built yet, and the rule is already stated: a projection is a reproducible view over its sources and never the authority for them.

  • Where people and programs read the evidence; nothing here writes. The Explorer shows the corpus and a profile per model. The Readout is the system in its own words, one door at a time. Verify checks a downloaded bundle on your device. The Judging Room, a prototype, is where a person compares two AI responses, chooses, and says why, with the judgment sealed on their own device. No rankings, anywhere.

  • How the project decides and how it admits error. Rules that each name what enforces them; a log of decisions; a disclosures record of public claims that were wrong, appended and never rewritten; a registry of open questions; outside reviews stored verbatim and answered in writing. Nothing is promoted while the tests are red, and a release that bypassed the promotion path is detected afterwards, not prevented.