The laboratory's work
The authority's dispatch lands at the bench. The laboratory reviews, accepts, and joins the evaluation project's dataspace; the test runs walk the Recommendation's declared procedure step by step, evidence captured as the work happens; and the test report accounts for every required form before it can be submitted. This is the flow where the model does the heavy lifting.
The flow at a glance
The actor is the laboratory's operator (Ms. Petra Horvat and Mr. Martin Berger of the Blefuscu Central Laboratory, BCL, a fictional laboratory) in the lab workbench at /app/lab. The arc: the inbox, the accept that joins the dataspace, the samples received at the bench, the model-driven runs, the test report submitted back to the authority, where flow 04 picks it up.
The walkthrough
The dispatch inbox: the request lands
The authority's send (flow 02, S8) lands here, in the incoming bucket of the laboratory's workbench: the request with its project, the subject instrument, the assigned test forms, and the samples on their way. The laboratory sees only what the scheme shares: the request and its context, not the authority's whole desk.
Try it:sign in as Test Laboratory, then work in/app/labon the demo instance.
Review: the decline wants a reason, the accept joins the dataspace
The laboratory's review mirrors the authority's: two honest outcomes. Decline, and the reason is required, audited, and the authority is notified. Accept, and the laboratory joins the evaluation project's dataspace: the working panels reveal with the chain context (the authority, the applicant, the instrument, the request) shared per the laboratory's cone. The record of who joined what, and when, is the audit chain doing its job.
Try it:sign in as Test Laboratory, then work in/app/lab/requests/…on the demo instance.
The laboratory's own view of the shared project
The joined laboratory reads the shared project through its cone: the instrument and its characteristics, the laboratory's own samples and assignments, the shared context. What is honestly absent is the authority's evaluation workspace; the laboratory never sees the verdicts being formed against its own work. The cone is what makes one shared record safe for three parties. (The built shape, named honestly: the test project the laboratory works is created by the authority's dispatch, one per laboratory; the laboratory's first act is the acceptance, not the creation.)
Try it:sign in as Test Laboratory, then work in/app/lab/projects/…on the demo instance.
The samples arrive at the bench
The custody chain ends at the bench: the laboratory registers the receipt of each shipped sample (the first with the full registration: serial, dimensions, photograph; the rest with the bare received mark) and the samples stand ready. The work's start stays closed while any sample is in transit, so testing never begins on samples that have not physically arrived.
Try it:sign in as Test Laboratory, then work in/app/lab/requests/…on the demo instance.
The runs walk the declared procedure
This is the substantial model-driven work. Open an assignment and the run's step wizard walks the test's declared procedure from the model: each step in the order the Recommendation declares (the MDLO-first sequence is the model's own gate, R 60-2 2.10/2.11), each parameter defined by the model, each acceptance criterion read from it. The header's tooltip is the proof: it quotes the test's purpose and clause from the conformance model, never hand-written text. Every step's evidence is recorded as the work happens, onto the attested record. Where a simulated instrument is bound (the SST), the twin's read prefills the record; without one the same run completes with manual entry, honestly.
Try it:sign in as Test Laboratory, then work in/app/lab/run/…on the demo instance.
The report accounts for everything, then submits
The test report is drafted first (before any run: the runs backfill the standing draft), and it cannot submit until it is complete. The completeness gate names what stands open: every run completed against its sample, every remaining required form carrying a justified omission (not applicable to this type evaluation, with the reason recorded), the signer's position given, the signature acknowledgment ticked. Only then does the report lock and travel to the authority through the shared project, landing in flow 04. A measured value outside the limits is never refused at the bench; it is recorded honestly and judged at the evaluation, by the verdict machinery, in the open.
Try it:sign in as Test Laboratory, then work in/app/lab/reports/…on the demo instance.
The laboratory's work (demo flow 03): the presenter scripts
OIML SMART demo walkthrough, printed from www.oimlsmart.org/demo/tl-work. Everything the scripts present is simulated: the demo instance resets nightly and the cast is fictional.
The presenter scripts
Two lengths, keyed to the steps above (S1 to S6). Print this page for a clean copy of the scripts.
The 5-minute presenter script · the committee slot
- 0:00Now the bench. The authority dispatched the work; the laboratory is where the Recommendation stops being text and becomes a procedure the software walks. Simulated cast, nightly reset.
- 0:30S1The dispatch inbox: the request with its tests and its samples, landed from the authority's send.
- 1:15S2-S3Accept, and the laboratory joins the shared project: the instrument, the samples, the assignments. What it does not see is the authority's evaluation workspace; the cone keeps three parties honest on one record.
- 2:15S4The samples: received at the bench, custody closed. Testing cannot start on samples still in transit.
- 2:45S5The run: the step wizard walks the procedure the R 60 model declares, in the model's own order, and this tooltip quotes the test's purpose and clause from the model itself. Evidence is captured as the work happens, not reassembled after.
- 4:00S6The report: drafted first, backfilled by the runs, and it cannot submit until every required form is performed or carries a justified omission. Then it locks and goes to the authority.
- 4:40Try it: the Test Laboratory account on demo.oimlsmart.org, /app/lab. Run one test yourself; the wizard carries you.
The 20-minute presenter script · the working visit
- 0:00Frame: this flow is where the model earns its keep. Laboratories do not need another portal; they need the procedure, the evidence discipline, and no re-typing. Simulated cast, nightly reset.
- 1:00S1-S2The inbox and the review: the decline-with-reason posture mirrors the authority's. Accept, and read the chain context aloud: the authority, the applicant, the instrument, the request. One record.
- 3:00S3The cone, demonstrated: the laboratory's project view shows the instrument and its own samples, and the evaluation workspace is absent. Name the built shape honestly: the test project is created by the dispatch, the laboratory's first act is the acceptance.
- 5:00S4The custody chain's end: the full registration on the first sample (serial, dimensions, photograph), the bare mark on the rest, and the start gate while anything is in transit.
- 6:30S5The run, in depth: open the wizard, walk a step, record an observation. The procedure, the parameters, and the acceptance criteria all come from the model; the MDLO-first order is the model's declared sequence (R 60-2 2.10/2.11), not a UI preference.
- 9:00S5The tooltip: open it and read the clause. Every guidance text on this surface derives from the model, so a laboratory in two countries reads the same procedure for the same Recommendation.
- 11:00S5The honesty about verdicts: a measured value outside the MPE is recorded, not refused at the bench. Setup constraints refuse (you cannot run the wrong sequence); the verdict belongs to the evaluation, computed at flow 04, never to a red box mid-run.
- 13:00S5The simulated-instrument option: where the SST is bound, the twin's read prefills the attested record. Without it the same run completes by hand. This is the SMART+ rehearsal, and it is labeled as such; the walkthrough claims nothing future as present.
- 15:00S6The report composer: the draft-first order, the completeness gate naming the unrun assignments, the justified omissions (PD-05: the report accounts for every required form), the signature acknowledgment.
- 17:30S6Submit: the report locks and lands on the authority's project with the notification. Preview flow 04: the authority now validates this evidence against the same model the laboratory ran.
- 18:45Questions. The usual: calibration status (the laboratory's own scopes govern what it can accept) and twin binding (roadmap-tier, shown as rehearsal only). Close on the try-it path: the Test Laboratory account, /app/lab.
Today (SMART) and the vision (SMART+)
Today · SMART
- The dispatch inbox, the reasoned decline, the acceptance that joins the project dataspace per the TL cone. the workbench ↗
- The model-driven runs: the declared procedure as a step wizard, per-step evidence, the model-fed tooltips, the attested record. run a test ↗
- The completeness-gated report: justified omissions, the signature acknowledgment, the locked submission to the authority. the reports ↗
The vision · SMART+
- The SST-bound run: the simulated instrument's twin read prefilling the attested record and driving the chamber (roadmap-tier; piloted on the demo as rehearsal). roadmap ↗
- Signed measurements: the run's evidence signed at the instrument, verifiable by the authority without re-trust (roadmap). roadmap ↗
The honest questions
Does the software judge the measurements?
At the bench, no: the run records the evidence and enforces the procedure's setup constraints (order, parameters), and a value outside the limits is recorded honestly. The verdict is computed at the evaluation (flow 04) from the same model, in the open, by the authority's machinery. The laboratory performs; the authority evaluates.
What keeps a report honest?
The completeness gate: every assigned run accounted for, every required form either performed or carrying a justified omission with its reason, the signer's position, and the signature acknowledgment. The report locks at submission, so what the authority reviews is exactly what the laboratory signed.
Our laboratory already has a LIMS. Is this a replacement?
No: it is the scheme-facing half of the work. The request, the shared project, the model-driven procedure, and the report the authority can compute against are what the platform carries; the laboratory's internal systems stay internal. The records-mode bridge (register a report performed offline, honestly marked) exists for the transition.
Is the simulated instrument required?
No. Where a twin is bound, its read prefills the record as a rehearsal of the SMART+ tier; the same run completes with manual entry and says so. The walkthrough's claims stand without the simulator, and the pages never present the rehearsal as a shipped capability.
Where to go next
The report's other side: the authority validates the evidence against the model, runs the review period, and issues the certificate.
The Test Laboratory persona, assumed through the identity service, then /app/lab. The named operators (Petra Horvat, Martin Berger) are the operator seats.
info@oimlsmart.org for a working visit with your laboratory's team.
Verified 2026-09-01: every step above was performed headlessly against the live demo by scripts/capture-walkthroughs.ts (one real assignment accepted, samples received, runs completed, and a report submitted in the drive) and each capture carries its assertion record in public/img/walkthroughs/manifest.json. The step names and machine states match the engineering record (DEMO_FLOWS/03) in the smart repository; where the built shape differs from the flow text, the step says so (S3, S6).