An abstract makes promises. JevPaper shows you where the paper keeps them.
A Chrome extension that marks every claim in an arXiv abstract, the sentence in the body that delivers it,
and the assumptions and limits worth knowing, right on the page, in about two seconds.

Install · How it works · How good is it · Privacy · 简体中文

_{Real run on Attention Is All You Need: open the paper, the marks appear, click a claim to jump to its evidence, click again to come back, raise the level for caveats and more candidates.}

---

It never writes a word

Most AI reading tools summarise. Summaries paraphrase, and a paraphrase can be wrong in ways you cannot see.

JevPaper does not generate text at all. Every mark is a sentence the authors wrote, highlighted where they wrote it, so you always read it in its own context. The judging is done by Jev, TypeSafe's System One model. Jev does not write prose; it answers typed questions with probabilities: which of these sentences delivers this claim? Is this sentence a limitation? Code decides what to show. There is nothing to hallucinate, only sentences to rank.

What you get

Claims, and where they are delivered. Each claim in the abstract is marked in blue. Hover it to see its role (method, result, contribution); click it to jump to the body sentence that delivers it, marked in yellow. Click that sentence's tip to jump back.	Caveats and more candidates. Raise the level to see the assumptions, conditions and limitations a careful reader should know (pink), and the runner-up evidence (pale yellow).
Three levels, one button. Claims and evidence; plus assumptions and limitations; plus more candidates. The menu is also the legend. Changing the level repaints instantly and asks for nothing new.	At home in dark mode. The bands follow arXiv's own theme switch, with a palette whose contrast against body text is measured, not guessed.

And the details that make it pleasant to read with:

• Bands, not boxes. Marks sit behind the text as continuous bands, one per line, with no gaps between lines, and step around display equations instead of painting over them.
• Fast. About two seconds after the page loads. Each paper is computed once and cached on your machine, so reopening it, reloading it or changing the level costs nothing.
• Keyboard friendly. Every claim and its evidence are reachable with Tab and Enter; the menu is a radio group with arrow keys; motion respects reduce motion.
• Yours. No server, no account, no analytics. You bring the key.

Install

Note

JevPaper is a preview. Its interface speaks English or Chinese, following the language of your Chrome.

1. Download jev-paper-0.2.0-chrome.zip from the latest release and unzip it into a folder.
2. Open chrome://extensions, turn on Developer mode, click Load unpacked and pick that folder.
3. Pin JevPaper, click its icon, paste an OpenRouter key and press Get started.
4. A short guide opens. Press Try it to open Attention Is All You Need and watch it get marked.

After that, open any paper's HTML full text, arxiv.org/html/<id>, or its ar5iv page. JevPaper does nothing on abstract pages or PDFs.

Other services, and building from source

Services. OpenRouter is the default. You can also use TypeSafe, Jev's own API, or any endpoint that speaks Jev's System One protocol, with a model id of your choice. JevPaper checks the key with one small request before saving it.

From source. You need Node.js 22+, pnpm 10 and Chrome 128+.

pnpm i
pnpm build        # then Load unpacked: .output/chrome-mv3
pnpm dev          # Chrome with the extension loaded, reloading as you edit
pnpm zip          # a zip like the one in the release

How it works

flowchart LR
    P["arXiv page"] -->|"sentences"| X["JevPaper"]
    X -->|"questions"| J(("Jev"))
    J -->|"probabilities"| X
    X -->|"marks"| P

Loading

1. Cut. The content script cuts the paper into sentences in the page itself, keeping formulas and display equations intact, and maps each sentence back to its exact place in the page.
2. Judge. The service worker asks Jev two rounds of small, parallel questions. Round one asks what each abstract sentence is (a method, a result, a contribution, or background), which body sentence delivers each claim, and what kind of caveat each body sentence is, if any. Round two re-ranks each claim's best candidates with a question worded for its role, verifies them, and scores the likeliest caveats.
3. Paint. Only sentence ids and scores come back. The page paints them as bands behind the text, and the result is cached so the paper never costs twice.

A paper takes roughly 20 to 40 requests in two rounds and about a cent through OpenRouter. The question design was chosen by measurement: in a review of alternatives (one yes/no question per caveat label, graded scores, pointwise re-ranking, a single round), every other way of asking lost quality. The one saving that held up, packing the second round into fewer requests, is in.

How good is it

We hand-labelled 12 papers sentence by sentence, from ResNet, the Transformer, LoRA, DDPM, DPO and the scaling laws to four 2026 preprints: which abstract sentences are claims, which body sentences deliver each claim, and which sentences a careful reader must know as caveats. Six papers were used to design JevPaper and six were kept aside to test it.

	Design set 6 papers, 41 claims	Held-out test set 6 papers, 32 claims
Claims found in the abstract	96%	94%
The delivering sentence is in the top 3	88%	97%
The delivering sentence is ranked first	77%	64%
Caveat ranking (average precision)	0.53	0.49

Measured in September 2026 with typesafe/jev-1.13-20260917 through OpenRouter: 1 to 3 seconds and $0.005–0.015 per paper. Every release is checked against this set before it ships.

Privacy

• What leaves your computer. The paper's title and its sentences, as cut from the page you opened, go to the service you chose (OpenRouter, TypeSafe or your own endpoint), sent with your key. Nothing goes anywhere else. JevPaper has no server of its own and no analytics.
• What stays on it. Your key is kept in chrome.storage.local on this device and is never synced. The marks for each paper are cached in the extension's IndexedDB, up to 500 papers. Papers opened in incognito tabs are not cached.
• Where the key can be read. The extension's own code reads the key only in its service worker and its popup; the script that runs on arXiv pages never reads it, and a test keeps it that way. Chrome itself does not enforce this, since it lets any content script of an extension read chrome.storage.local. The isolation holds because of how the code is written, not because the browser prevents it.

Permissions: storage for the key, the level and the cache; host access to openrouter.ai and api.typesafe.ai, the two preset services (a custom endpoint's origin is requested when you save it); a content script on arXiv and ar5iv HTML pages, top frame only.

FAQ

Why only the HTML version of arXiv papers?

Marks have to sit exactly on the sentences a reader is looking at. arXiv's HTML full text is real text with real structure (sections, equations, footnotes), so every sentence maps back to its place on the page. PDFs are positioned glyphs, and abstract pages have no body to find evidence in.

Why Jev and not a chat model?

JevPaper needs judgments, not prose: many small, typed, parallel questions whose answers are probabilities that code can rank. That is what System One models are built for, and it is why a paper takes seconds and costs about a cent.

What does it cost, and does it charge twice?

About $0.005–0.015 per paper through OpenRouter, paid with your own key. Each paper is computed once and cached; reloading, reopening, opening it in a second tab or changing the level makes no new request. If you leave a paper while it is still being computed, the unfinished work is dropped.

Which languages does it speak?

English and Chinese. JevPaper follows the language of your Chrome: Chinese in a Chinese Chrome, English everywhere else. The marks, of course, are on the paper itself, in whatever language it is written.

Roadmap

• English interface
• Chrome Web Store listing
• Firefox

Development

pnpm test         # unit tests (Vitest + happy-dom)
pnpm e2e          # end-to-end: the built extension in Chromium, saved arXiv pages, a local stand-in for Jev
pnpm typecheck && pnpm lint

• pnpm test downloads a few arXiv pages the first time it runs. They are fixtures that arXiv may distribute but this repository may not; each is checked against a recorded SHA-256 and kept, git-ignored, in tests/fixtures/.
• pnpm e2e needs Playwright's Chromium (pnpm exec playwright install chromium). It uses no key and costs nothing; it loads arXiv's own style sheets from the network.
• pnpm notices regenerates public/licenses/THIRD_PARTY.txt after a dependency changes.

Built with WXT and TypeScript: React for the popup and the guide, a framework-free content script on the page, Dexie for the cache and zod for stored settings.

Credits

• Jev and its System One protocol are by TypeSafe; OpenRouter serves it.
• Sentence extraction, formula handling and band painting build on Read arXiv, a bilingual reader for arXiv HTML by the same author.
• The highlighter icon is from Lucide.

Licence

JevPaper is free software under the GNU General Public License v3. Files adapted from Read arXiv (also GPL-3.0) name their source in their first line. The Lucide icon is under the ISC licence (public/licenses/lucide.txt); the libraries bundled into the extension keep their own licences (public/licenses/THIRD_PARTY.txt).