Skip to content
OnySnow Studios

Every claim,traced to its
source.

The Workbench running, on a demo case built from public records. The case home: the question, where each stage stands and the one decision only you can make next. Pointing at a party lights it everywhere it appears. Recorded from the running app.

The Journalism Workbench is a private, local-first investigation desk for reporters and citizen investigators. Bring in documents, check every claim against its source, see who is linked to whom and where the money went, and act only on what holds up. The AI is optional and bounded: it can propose, never decide.

My role
Founder, product lead and designer; I direct the engineering
Status
In active private development, 2026
Built with
Python and FastAPI, PostgreSQL, Next.js, OpenAleph, local models
Scale
16 approved screens · 14 recorded decisions · ~300 test files

A pile of records, a hunch,and no research desk.

An independent reporter gets documents as PDFs, scans, emails and spreadsheets. The same names repeat across hundreds of pages, spelled three ways. There's no research desk, no lawyer on call, and one overstated sentence can sink a story and hurt someone who did nothing wrong.

AI makes it faster to be wrong. A database match, a scanned page or a model's guess all look like facts. In the Workbench, every one of them enters as a lead or a proposal, never as a fact.

Bring it in: drop files, a folder or a link, and each one is shown moving through seven steps, problems first. Design mockup on a fictional teaching case.

When the app says Supported, I can publish that sentence and defend it to a lawyer.

The job the app has to do, from the design research

A human gate beatsa smarter model.

The person decides.Nothing skips human review, and nothing is silently merged or overwritten. The AI's output is never trusted directly.
A written method can be enforced in code.My Authority System Suite becomes database fields and server checks, and drift between the method and the app is a failing test.
“Supported” should mean publishable.A claim earns the word only when the server confirms the evidence: the source says it, the passage is located, the file's fingerprint matches, and contradictions are answered.
You should be able to watch the AI think.Its reasoning should be visible as it happens, not a black box with a verdict at the end.
Patterns are not verdicts.A red flag is a reason to look closer, and every one lists its innocent explanations.
Calm, cinematic design helps long, high-stakes sessions.One screen per job, dark colours that are never black, and effects that switch off wherever you read.

It can propose.It can never decide.

  1. 01

    Packet

    The model sees only a packet of records a person has already reviewed. Nothing else.

  2. 02

    Method

    Its instructions are the Authority System Suite's own modules, with the run settings shown in plain words first.

  3. 03

    Guard

    Instruction-like text hidden in the evidence (“ignore previous instructions”) is caught and shown before the run.

  4. 04

    Gates

    Every answer must pass the schema, every citation must be in the packet, and every quote is checked word for word.

  5. 05

    Proposal

    What survives lands in a review queue as a proposal. Nothing joins the case until a person accepts it.

The same pipeline, live on a demo case: the model's answer was stopped at the citation check because it cited a record that wasn't in the packet. Nothing is saved; the review waits for the person.

The AI never types a number

Charts are ordered from a fixed catalogue of queries and their values computed from the records. A model can ask for a chart; it can't write the figures in it.

Private by default

Models run on the reporter's own computer. Remote services are refused unless explicitly allowed, fonts are bundled so nothing calls out while a sensitive case is open, and every outbound request is logged word for word.

Before you run. The method's settings in plain words, the plan you can edit, exactly what leaves the computer, and the limits that can't be turned off. The red box is the injection guard at work.
Watch the run. Each step travels as light through the app's checks and the method's systems, and any thought can be traced from input to output. Status is the app's, never the model's.

How this factgot here.

CheckRecorded from the running appCheck, running on the 1MDB demo case: every claim shows its evidence and its status, in a shape and a word.
The WireRecorded from the running appThe Wire, running: parties drawn by how they are linked, then the shortest chain of payments between two of them.
Red flagsRecorded from the running appRed flags, running: ranked, each with a “before you call it” list of innocent explanations.
Chain of custodyDesign mockup, fictional teaching caseFile → reading → passage → decision → claim, the file's fingerprint re-checked on load, and a log you can export for an editor or a lawyer.
The reading roomDesign mockup, fictional teaching caseA calm page with no effects, proposals in the margin tied to their exact words, and every decision held a few seconds with undo.
Where the money wentDesign mockup, fictional teaching caseMoney that appears or vanishes is the finding, so it's drawn: a hatched ghost labelled “No recorded source”.
Red flagsDesign mockup, fictional teaching caseGraded Faint, Strong or Textbook by shape and word, never colour alone, each with a “before you call it” list of innocent explanations.
StoryDesign mockup, fictional teaching caseA branch is only as strong as its weakest claim, and export stays disabled until every sentence has a source.

Cinematic where it helps,calm where it matters.

The case home mockup: the question at the top, standing numbers, one module per stage, and the next decision in the middle with its source beside itThe same screen in the running app, on a demo case built from public recordsApproved mockupRunning app
Drag the line: the approved mockup the case home was built from, against the running app. The mockup screens on this page are design mockups on a fictional teaching case; the recordings are the running app on a public-records demo case.

The first version worked and was hard to use. So I stopped and redesigned every part from research: a 252-page study, 16 screens approved as mockups before any code changed, and a build list that checks every screen against its picture.

Five themes share one status grammar: ✓ supported, ✕ disputed, a dashed ring for not yet shown, dotted for anything the app worked out itself. Every theme is contrast-checked, and a theme maker refuses to save a pair that fails.

Rain Noir, a city at night through a wet window, is built from the light engine I wrote for this site. Effects never sit over text, and they switch off in the reading room, tables and the chain of custody.

The light engine →
The themes: Case Night, Rain Noir, Archive and Forest Ledger, each with its own type and palette.
Try a theme on your real case before keeping it, and switch each effect by name.

Directing the work,decision by decision.

  1. The engine: provenance on every fact, sanctions and outside-database lookups, a relationship graph, and previews that run with no AI at all.

  2. My own rigor method becomes the AI layer: the suite's modules, vocabularies and settings, with tests that fail if the two drift apart.

  3. Decision: stop rebuilding document reading and search, and build on OpenAleph, the open-source tool newsrooms already use.

  4. 2,946 published red-flag indicators in 42 areas, kept as reviewable data with one source for the engine, the glossary and the printed guide.

  5. Turning point: “This entire site needs redesigned. It is not user friendly at all.” A 252-page redesign study follows.

  6. 16 screens approved as mockups. The build list tracks every screen against its picture, item by item.

  7. Watch the run, the theme maker, the indicator catalogue, and “reading never writes”: opening a page can no longer change the case.

The indicator catalogue: 42 areas and 2,946 published red-flag indicators, kept as reviewable data.

A tradeoff

Building our own document reading, OCR and search would have kept everything in one codebase. Building on OpenAleph meant giving up that control, and in return the app stopped doing the same job twice and inherited a tool newsrooms already trust. Reading its source showed one of its features had never been switched on.

How I run it

The engineering is done by AI agents working under written doctrine: recorded decisions, an audit-and-fix loop, mockups approved before code, and a rule that a problem in the method is reported to the method, not patched in the app.

What isn't on this page

The app is private. The mockup screens here are design mockups on a fictional teaching case; the recordings are the running app on a demo case built from public records. No private investigation appears, and security details stay out too. I'm happy to demo it live.

Ask for a demo →

I'm open to creative technical project management, founding teams, and agentic AI engineering and research. I read everything that comes in, and I answer.

onysnowstudios@gmail.comLinkedIn →

Resume