Tiphareth Studio

The Ecosystem · 2026

The Saurus

A synthesis you cannot follow back to its sources is just confident prose, so every sentence the machine writes must carry the address of its evidence.

A literature-review pipeline that devours a corpus of scientific PDFs and hands back a review where every claim carries its address, paper, page and paragraph, plus a chat that only knows what the pipeline actually extracted.

The Saurus papers view, one uploaded paper expanded into its extracted themes as colored chips and fifty-five claims, each claim carrying its address in the source, page and paragraph.

The Saurus papers view, one uploaded paper expanded into its extracted themes as colored chips and fifty-five claims, each claim carrying its address in the source, page and paragraph.

The load

A model will summarize anything. That is the problem.

Reviewing a corpus of papers is exactly the work a language model seems built for, and the naive version of it fails in a specific, dangerous way: the output reads perfectly and cannot be audited. The failure is not bad prose. It is prose whose relationship to the sources is unknowable.

  1. The confident summary

    Hand a model twelve papers and ask for a review, and a fluent one comes back. Which paper backed which sentence, whether two papers actually disagreed, whether a finding was one study or five: none of it is recoverable from the text. Reading it means trusting it.

  2. Citation by vibes

    Asked to cite, a model produces things that look like citations: plausible authors, real journals, page numbers with the right typography. Some point at papers not in the corpus, some at nothing at all. A bibliography is decoration unless every reference can be walked.

  3. The context window is not a corpus

    Stuffing the PDFs into one giant prompt fails quietly: content is truncated without notice, material in the middle is systematically underweighted, and the whole reading happens in one pass with no intermediate artifacts anyone can inspect.

  4. The chat that knows too much

    A typical assistant over documents blends what it retrieved with what the model already believed. The answer sounds grounded either way, and there is no way to ask which parts came from your papers and which from the model's general opinions about the field.

  5. One crash, the whole bill again

    A multi-stage run over a real corpus is minutes of LLM calls with real cost. Naive orchestration ties its fate to one process: a crash at the last stage throws away every finished one, and the retry pays for all of it a second time.

  6. Quality asserted, never measured

    Most LLM pipelines ship with no evaluation at all: quality claims rest on a handful of cherry-picked runs, and every prompt edit is a blind change to the system's behavior. Whatever the demo showed, nobody can say whether yesterday's tweak made it worse.

The difference that matters

a claim in a summary …the trail ends in the air the same claim, with an address paper 2, page 4, §7 the two sentences read identically: only one of them can be checked
Two claims can read identically and differ in the only way that counts: one can be checked and one cannot. Fluency gives no signal about which is which, so the checkability has to be built in as structure, not requested in a prompt.

The reframe

The unit of synthesis is the claim, and a claim has an address.

The Saurus never asks a model to read a pile and write an essay. It decomposes the work into stages whose outputs are inspectable artifacts: claims extracted per paper with page and paragraph, themes deduplicated across the corpus with authorship kept, a review assembled from that structure with the addresses carried through into the prose.

The assistant only knows what the pipeline extracted. What was not extracted is not said.
The naive pass The decomposed pipeline
One prompt, one essay, no trail Four stages, each leaving an inspectable artifact
Citations that merely look like citations Inline addresses: paper, page, paragraph, walkable
Themes blurred across the whole corpus Duplicates merged, attribution kept per paper
Chat mixing retrieval with model opinion Chat that reads only the extracted store
A crash pays the full cost again A journal resumes from the last finished stage
Prompt edits shipped on faith Prompt edits gated by a fixed evaluation suite

The second reframe: hallucination is an interface problem

The usual framing treats hallucination as a model defect to be prompted away. The design here treats it as an interface defect: a system that lets ungrounded text reach the reader unlabeled has already failed, whatever the model did. So the pipeline's job is to make the grounded path the only path, extraction before synthesis, addresses carried through, and a reading side that is structurally unable to reach past the store.

That is why the assistant is deliberately poorer than the model behind it. It could answer from general knowledge; it is not allowed to. Six typed tools over the extracted claims are its entire world, which is precisely what makes its answers worth something.

What the system carries

Four stages of writing, one narrow door for reading

Each piece exists to keep the chain of custody intact: from a page in a PDF to a sentence in the review to an answer in the chat, without any link where the evidence goes anonymous.

Extraction, per paper

One agent reads one paper and emits themes and claims as structured output, each claim stamped with its page and paragraph. Papers run in parallel lanes, stateless, throttled by a shared semaphore, so the corpus scales without the agents ever sharing a context.

paper analyzer

Deduplication with authorship

The same finding phrased six ways across six papers is one theme, not six. The merge is semantic, and it keeps the ledger: which papers contributed to the theme survives the merge, because attribution lost here is unrecoverable later.

theme dedup

Synthesis that carries addresses

The review is assembled from the extracted structure, themes reviewed in batches, then aggregated into cohesive prose whose inline citations resolve to paper, page and paragraph. The style of a literature review, with the audit trail of a ledger.

reviewer · aggregator

The narrow-door assistant

An embedded chat answers questions about the corpus through six typed tools over the claim store, and through nothing else. It cites what it reads. Ask it something the pipeline never extracted and the honest answer is that it does not know.

agno team · mcp

The evaluation gate

Faithfulness and relevance are scored by RAGAS and DeepEval against reference cases, traces are scored automatically in Langfuse, and prompt changes run as regression tests: the same fixed suite, before and after, with the diff as the verdict.

ragas · deepeval · langfuse

The journal

Pipeline stages run as durable steps whose results are journaled by Restate. A crash mid-run replays the journal, returns the finished stages from the record, and re-executes only from the point of failure. The retry costs the failure, not the run.

restate

The walk

One corpus, from drop to review, on screen

The same flow the diagrams argue, photographed from the running app: papers go in, the pipeline narrates itself stage by stage, and what comes out is a review whose every bracket can be walked back to a page.

1 · Feed it your papers

The upload screen: the dinosaur mascot eating a paper, above a drop zone for scientific PDFs.
The front door. Drop a corpus of scientific PDFs and the pipeline takes over; the mascot is a promise about appetite, not a metaphor about rigor. The rigor comes next.

2 · Watch it narrate itself

The live pipeline trace mid-run: Paper Analysis and Theme Deduplication checked off, Theme Review in progress at fifty percent, and an event trace listing agent events with timestamps, including nine themes deduplicated to four.
The run is not a spinner. Four stages check off in real time over a live event stream, agent by agent, and the artifacts are already inspectable while it works: this run's dedup merged nine extracted themes into four, and said so at the moment it happened.

3 · Read the review, hold the receipts

The finished literature review: a metrics bar counting two papers, sixteen themes and one hundred eleven claims, above synthesized prose whose bracketed citations resolve to claims.
The output: two papers became sixteen themes and one hundred and eleven claims, synthesized into prose where every bracketed citation resolves to a claim with its paper, page and paragraph. The expanded view of those claims is the image at the top of this page.

4 · Ask, and it cites what it read

The Dino Assistant drawer open beside the review, answering a theme overview question with claims cited by paper, page and paragraph, each drawn from the extracted store.
The narrow door in practice. The assistant answers through six typed MCP tools over the claim store and through nothing else. Every claim it surfaces carries paper, page and paragraph, because those are the fields the tools return. Ask it something the pipeline never extracted and the honest answer is silence.

Architecture

One side writes, one side reads, and the store is the whole vocabulary

Two decisions carry the design. The first is the write/read split: the pipeline is the only writer of the claim store, the assistant its only reader, so grounding is a property of the wiring rather than a promise in a prompt. The second is that execution is durable and observable end to end, because a pipeline of paid LLM calls that cannot resume or be traced is a demo, not a system.

The write/read split

the pipeline reads the papers, extracts, deduplicates writes what was extracted six typed tools the assistant answers questions, cites what it reads no direct path back to the papers, none to the model's own opinions one side writes, one side reads: the store between them is the whole vocabulary
The pipeline extracts and writes. The assistant reads through six typed tools and cites what it reads. There is no path from the chat back to the raw papers, and none to the model's own general knowledge: what was not extracted cannot be said.

The separation is what makes both halves honest. The writing side can be aggressive, parallel agents, semantic merging, batch synthesis, because everything it produces is a file someone can open: claims, themes and reviews land as YAML, events as NDJSON. The reading side can be trusted precisely because it is weak: a federated chat panel, lazy-loaded into the app, whose backend reaches the corpus only through the MCP server's typed tools over the vector store.

The same discipline extends downward. Every LLM call is traced in Langfuse with cost and latency attached, and two standalone test clients exercise the full stack over HTTP, WebSocket and Socket.IO, so a deployment can be verified end to end from a terminal, by a person or by a coding agent.

One corpus, end to end

each paper, its own lane merge synonyms, keep authorship review, in batches the review the journal: one tick per finished stage a crash resumes here, at the last tick, not from zero
Parallel analysis lanes meet a deduplication barrier, merged themes are reviewed in batches, one aggregation writes the review. Under every stage, a journal tick: a crash resumes from the last tick, not from zero.

The stage boundaries are not just checkpoints, they are the places where the system's claims become checkable. After analysis you can read exactly what was extracted from each paper; after deduplication, exactly which papers back each theme; after aggregation, exactly which claims back each sentence. The pipeline's honesty is the sum of its intermediate artifacts.

Durability comes from Restate journaling each stage as a workflow step. The choice is pragmatic rather than ideological: a run over a real corpus is minutes of metered calls, and the difference between resuming and restarting is the difference between an error and a bill.

The substrate

Five services in one repository: the React host app, the federated chat UI, the FastAPI pipeline, the Socket.IO chat backend, and the MCP server, with Qdrant and Langfuse alongside. State is YAML on disk, events are NDJSON, and the vector store is a graceful side-effect: the pipeline produces its review even with Qdrant switched off.

The whole surface is covered the way a production system would be, 309 unit tests across the four backend services, evaluation suites, tracing, Terraform for AWS and a Helm chart for Kubernetes, because the point of the piece is precisely that coverage. It is a demonstration project, and what it demonstrates is the full checklist.

  • Appupload, live pipeline trace, the review
  • Assistantthe narrow-door chat, federated into the app
  • Pipelinefour agents, durable stages, structured output
  • Papers MCPsix typed tools over the claim store
  • EvalsRAGAS, DeepEval, prompt regression, Langfuse scoring

What survives a prompt edit

Quality is a number with a history, not an impression

The part of the system that outlives any single run is the evaluation harness. Reference cases, LLM judges, automated scoring on traces: together they turn the vaguest sentence in AI engineering, this prompt seems better, into a measured comparison on a fixed suite.

prompt, version one prompt, version two same cases, same judges its score its score worse better a prompt edit is a code change: it ships only if the same suite says it may
Two versions of the same prompt, the same cases, the same judges, one shared scale. The edit's effect is a drawn distance, not a feeling, and an edit that scores worse does not ship.

The Saurus is the studio’s demonstration piece for one discipline: keeping the chain of custody on machine-written claims. It is a public repository built to cover the whole production surface, multi-agent orchestration, structured extraction, durable execution, evaluation suites, observability, infrastructure definitions, and it is exactly what it says it is: a demonstration, not a system serving real traffic. The honesty cuts both ways. The coverage is real, 309 unit tests, RAGAS and DeepEval suites, Langfuse tracing, Terraform and Helm, and so is the label.

The argument it makes lands beyond literature review. Any system that lets a model synthesize over private documents faces the same three questions: can each output sentence be walked back to evidence, can the conversational layer be structurally prevented from knowing too much, and can a prompt change be shipped with a number attached instead of a feeling. The Saurus answers all three with architecture, extraction before synthesis, a write/read split with typed tools as the only door, and an evaluation gate in front of every behavioral change.

The name is the joke it appears to be, a thesaurus crossed with a dinosaur that eats papers, and the repository’s own tagline is “feed The Saurus your papers.” The piece takes its discipline seriously and itself less so, which is roughly the studio’s preferred ratio.

← All works