She didn't call.
readingassertion
polaritynegative
statusasserted
≈ 0.5one score
trust center
A trust center for the age of generated language.
Text is now generated at an unprecedented scale, and the riskiest prose is often heavy on confidence and light on reliability. Rheme reads the meaning underneath the words, who is claiming what and how surely, and shows them to you plainly. It leaves the judgment where it belongs, with you.
Trust does not come from a tool telling you what is true. It comes from being able to see the structure of what was said and decide for yourself.
the problem
When everything sounds true.
A modern model can hand you a fast, confident synthesis, and the same fluency that makes it useful lets it pass off an analysis that is confidently wrong. From any distance the two look the same. The risky sentences are the quiet ones. A hedge gets recorded as a fact, a quote gets treated as the writer's own claim, an absence of evidence gets read as proof of the opposite. Once those distinctions collapse, a reader loses the ability to tell a settled fact from a soft one, and that is where trust breaks.
Almost every institution we depend on runs on prose. Contracts, medical notes, scientific papers, court filings, and the daily flood of news. Software stores it, search retrieves it, models summarize it, and almost none of it is actually understood, because society runs on assertions. Who said what, on what authority, with what obligation, and at what cost.
Look at how much hides inside one ordinary event. Here are four sentences about the same phone call. A person hears four very different things. Most software keeps only one.
She denied calling.
readingreported denial
polaritypositive
statusdisputed
≈ 0.5one score
No proof she called.
readingevidence status
polaritypositive
statusunverified
≈ 0.5one score
She might have called.
readinghedge
polaritypositive
statuspossible
≈ 0.5one score
our answer
Show the structure, never render the verdict.
Rheme marks the move a sentence makes. It shows that a claim is hedged, attributed to a source, denied, or built on evidence, and it draws each move as its own signal traced back to the exact words. It never labels a sentence true, false, or biased. The moment a tool hands down a verdict it takes a side and turns brittle, and people quietly stop trusting it. By holding to the structure and handing you the judgment, Rheme stays an instrument you can keep open all day.
what makes it trustworthy
Three properties you can rely on.
Deterministic, with no model in the loop
The same text returns the same reading every run, in well under a millisecond, with no model call behind it. There is no sampling and no drift, so a reading you cite today reads the same when a colleague opens it tomorrow. You can test it, diff it, and build a process on top of it.
It never flattens
Distinct signals stay distinct objects. A negation, a reported denial, an absence of evidence, and a hedge are four different things, and Rheme keeps them four. Nothing is melted into a single confidence number that hides which kind of claim you are actually looking at.
Every object is traceable
Each signal points back to the exact words that produced it. Nothing is surfaced that cannot be traced to where it was said, so you are never asked to trust a summary you have no way to check.
why it matters
Trust at scale is a semantics problem.
The connected world surfaced a hard fact about trust. It fails at scale because meaning itself is slippery. It flattens under pressure, sources fall away, and a careful claim is easy to bend. Lying is the least of it. People hedge, imply, deny, exaggerate, omit, recycle, launder, and blur, and Rheme makes those moves legible so a reader can follow them.
The same structure gives the software built on top of Rheme an epistemic basis. Before it acts, a system can ask whether a claim is confirmed or only alleged, whether the source is primary, whether anyone has denied it, and whether the evidence has gone stale. A claim that carries its own provenance can be followed through its whole life, who first made it, what supported it, what contradicted it, and who changed it along the way.
Rheme holds the line between saying and knowing, between proving and denying.
how we hold ourselves to it
Trust is something you earn on the record.
A trust center is only worth the standard behind it. Rheme is built on a posture the team keeps in public. Evidence outranks confidence. When we overclaim, we correct it out loud. Nothing is called done until it has survived a real attempt to break it, and an independent check beats our own grading every time.
Evidence over confidence
A reading earns its place from the words on the page, not from how sure a model happens to sound.
We correct ourselves out loud
When a claim about the system turns out too strong, the record gets fixed in the open rather than quietly walked back.
Adversarial before done
Each result has to survive a pass that actively tries to break it before it is allowed to ship.
Independent over self-graded
We re-prove results on blind data, because a system grading its own homework is not evidence.
the evidence
A suite built to catch our own mistakes.
The runtime is checked against a set of adversarial cases, each one guarding a single distinction. A case passes only when the right structure appears and the dangerous misreading stays away. A reported denial must not be stored as a settled fact. A hedge must not harden into certainty. An absence of evidence must not flip into proof. Here is where that suite stands today, reported exactly as it is.
case pass rate11 / 11
span fidelity100%
required diagnostics100% recall, 0 forbidden misreads
object identity across an editpreserved
open a document~0.2 ms
query a position~10 µs
These figures are measured at fixture scale, not promised at production scale. They will be re-measured on hundred-thousand-token documents, and this page is updated when they are. We would rather show a smaller true number than a larger comfortable one.
We also wrote down what would prove the whole approach wrong. If span fidelity could not hold under edits, if those forbidden misreads became common on the core cases, or if a small change forced the entire document to be read again from scratch, the typed-runtime idea would have failed. None of those hold today, and we will say so plainly the day any of them does.
warnings that protect the reading
The runtime flags its own risky readings.
Some sentences are easy to misread in a way that quietly changes the truth. Rheme raises a diagnostic right there, drawn with a wavy underline rather than a clean mark, and it names the hazard without passing sentence on the source.
denial misparsed
A reported denial is kept disputed, and the event inside it is never stored as false.
absence of evidence
No proof of a thing is held apart from proof against it. Unverified is its own state.
modality erased
A hedge is never recorded more firmly than the source actually allowed.
causal overclaim
A claim of cause is flagged when the evidence on the page only shows one thing following another.
missing attribution
A factual claim made in the document's own voice with no source is marked so a source can be attached.
your words stay yours
Trust includes your data.
Rheme runs where your text already is. It loads no third-party scripts, sends no telemetry, and makes no request you did not ask for. The runtime ships to the browser and to native targets, so prose can be read on your own machine and never has to leave it. Because the reading is deterministic, anything the system reports can be reproduced and audited rather than taken on faith.
where we draw the line
What Rheme will not do.
The guarantees above are only real if they hold at the edges too. These are the lines the runtime keeps, by design, every time.
Hand down a verdict. It will not call a sentence true, false, or biased. It shows the move and stops.
Flatten the signal. It will not melt distinct claims into one score that hides which is which.
Guess in silence. When a reading will not settle, it raises a diagnostic and says so.
Phone home. It will not send your text anywhere or pull in an outside script.
Lean on a model at runtime. The reading is rule-based and deterministic, the same on every machine.
See it for yourself.
The docs run as a live reading of their own prose. Open them, or try the Inspector and watch your own words resolve.
Read the docs