The live ErisAI demo shows a product direction across dataset, model and compute-job workflows. This field note reads that interface as an argument: the decisions each screen is designed to support, the order in which facts are presented and the runtime state that still needs real compute behind it.
The demo is a product-direction surface. It demonstrates hierarchy, job flow and provenance communication; it is not evidence that a model, dataset or compute contract is live.
The first screen establishes provenance before the run.
ErisAI opens with a model registry, a dataset card and direct paths into a training or inference job. The useful design move is not the headline benchmark; it is the order of information. Model version, dataset reference, license, evaluation summary and target hardware appear before a wallet action.
That ordering is intentional. A credible AI workflow should let a visitor understand what is represented, which facts require verification and what compute is being proposed before a signature request appears.
The information order the interface is designed around - provenance first, signature last.
- Model and dataset context precedes wallet connection
- Primary actions are separated from supporting navigation
- Benchmark figures remain presentation values until bound to reviewed runs
Job cards are compressed runtime contracts, not marketing.
The job treatment explores how a training or inference run might be configured without reducing it to a single slider. Model weights, dataset slice, batch size, cost ceiling and receipt format are grouped into one review surface, while the fuller product would also need determinism guarantees, reproducibility records and evaluation evidence.
The demo therefore works as an information-architecture test: can a user distinguish model identity, dataset provenance, job parameters and system status at a glance? The production answer must come from verified records and the runtime itself rather than static interface copy.
Queued, running, certified and failed screens test state communication.
The runtime areas group queue position, compute estimate, current stage, cost and receipt states into focused dashboards. They show the vocabulary a connected product will need: queued, running, certifying, certified, restricted, failed and recoverable.
A production implementation must derive those states from the runtime, indexed events and policy checks. The interface should never imply completion merely because a wallet request was submitted.
- Separate submission from certification
- Show the source and freshness of job state
- Make failed and refund paths as legible as success
The next milestone is a verifiable receipt, not more visual polish.
The demo now provides a coherent product shell across registry, job setup and runtime review. The next credible step is binding one narrow inference path to a running model, a reviewed dataset record and an observable compute receipt.
That vertical slice should publish its assumptions, determinism bounds and unresolved boundaries alongside the interface. A smaller demonstrably correct run is more valuable than a wider surface filled with synthetic certainty.
Review the same demo through three lenses.
Start with this walkthrough for product flow, then use the architecture and evidence notes to examine what must sit behind the interface:
- Architecture note: Verifiable compute receipts without putting datasets on-chain
- Evidence boundary: What the compute slice proves - and what it deliberately does not
- Product dossier: ErisAI on the Ztakora platform
The live demo opens in a new tab so this note stays available as a reference while you explore it. Which state is live, which is simulated and which is still a design target is the question each screen should be able to answer; the operating boundaries are catalogued in the company brief.
Product-direction content only. No model, accuracy, cost or availability claim.
