Today we're shipping something new. It's not a feature. It's a layer.
Litmus — every NanoParse response now includes structured intelligence about the page your agent just read. Source authority. Freshness. Structural trust. Key figures. A TL;DR. All pre-computed. All zero-cost. All before the markdown hits your agent's context window. Now with 15 signals, with more on the roadmap.
The Problem: Agents Can't Smell
When you read a TechCrunch article, you see the domain and think "established news outlet, vetted." When you read a Substack post, you think "someone's opinion." You do this instantly, subconsciously, before you even process the words.
Agents can't do this. They read raw markdown. A startup funding announcement and a Reddit thread look identical to an LLM — both are just text. The agent has to figure out credibility from context clues buried in prose. It burns tokens. It hallucinates. It cites the wrong source because it didn't know one was a news outlet and the other was a forum comment.
Litmus fixes this at the infrastructure level.
What's in the Box
Every parse now returns an litmus object alongside your markdown:
{
"markdown": "# Article Title...",
"metadata": {
"title": "Article Title",
"description": "...",
"domain": "techcrunch.com"
},
"litmus": {
"source": {
"type": "news",
"authority": 0.82,
"rationale": "established tech news outlet"
},
"freshness": {
"published": "2026-08-04",
"age": "4 days ago",
"stale_warning": null,
"modified": "2026-08-06",
"has_correction": true,
"correction_note": "Contains 'Update:' marker in body"
},
"tldr": "Acme Robotics raises $3.5B Series E at $61.5B valuation, led by Horizon Capital.",
"key_figures": [
{"value": "$3.5B", "context": "Series E raise"},
{"value": "$61.5B", "context": "post-money valuation"}
],
"structural_trust_score": { "level": "high", "trust_factors": ["low hedge density", "high authority source"] },
"hedge_language": {
"density": "low",
"markers_found": 3,
"per_500_words": 1.2
},
"content_density": {
"thin_content": false,
"substantive_sentence_ratio": 0.68
},
"syndication": {
"detected": false,
"note": null
},
"paywall": {
"detected": false,
"note": null
},
"reading_time": { "minutes": 5 },
"is_archived": { "archive_org": true, "archive_is": false },
"outbound_authority": { "score": 0.72, "top_domains": ["nih.gov", "nature.com"] },
"boilerplate_ratio": { "ratio": 0.05, "confidence": "high" },
"content_type": "news_article"
}
}Fifteen signals. Zero LLM calls. Every field is computed from the page itself — regex, heuristics, domain classification. No AI generating the intel. The intel is there so your AI doesn't have to guess.
Source Authority
Every domain gets classified and scored. .gov → government, 0.95 authority. Academic → 0.85. News → 0.70. Forum → 0.25. Social → 0.15. Known high-authority domains like nih.gov and nature.com get a boost. User-content platforms like Medium and Substack get penalized.
Your agent can now rank sources before it reads them. The TechCrunch article gets priority. The Reddit thread gets flagged.
Freshness Detection
We extract publish dates from meta tags, article schema, and HTTP headers. If a page was published two years ago, your agent knows. If no date is found, the agent gets an explicit warning: "No publish date found — verify independently."
Agents can't smell staleness. Now they don't have to.
Structural Trust Score
Every parse gets a trust score — high, medium, or low. Based on source authority, freshness, outbound link quality, content signals, and language patterns. A recent TechCrunch exclusive citing primary sources = high trust. A Reddit thread with speculative language and no external citations = low trust.
Your agent gets a structured trust assessment before reading a single word — not a hallucination detector, but a composite of structural signals that correlate with reliability.
Key Figures
Prices, percentages, statistics, large numbers — extracted upfront. "$3.5B", "$61.5B valuation", "led by Horizon Capital". Your agent doesn't have to scan 3,000 words of markdown for the numbers. They're in a structured array.
TL;DR
The page's own meta description or lead paragraph, surfaced as a structured field. Not an AI-generated summary — the page's own summary. Your agent can cite it directly without reading the full text.
Correction Detection
Articles get updated. Press releases get corrected. Without correction detection, your agent cites the original version of a page that was revised three days later — without knowing the revision exists. Litmus now tracks both original publish date and last-modified date, and scans body text for correction markers ("Update:", "Correction:", "Editor's note:"). When a page has been revised after publishing, your agent gets an explicit flag so it knows: this page changed. Whether the correction matters is for your agent to decide — but knowing it exists is the first step.
Hedge-Language Density
High-authority sources can still be full of hedging. "May lead to," "sources say," "reportedly," "could potentially" — all signal uncertainty, regardless of who published them. Litmus now measures hedge-language density as an independent axis, orthogonal to source authority. A Wall Street Journal article full of "according to anonymous sources" gets flagged for high hedge density, even though WSJ scores high on authority. A small blog with declarative, evidence-backed claims scores low. Your agent can now distinguish confident claims from qualified ones — across every source type.
Content Density
Some pages are all wrapper and no content. A 2,000-word page where 1,800 words are navigation, ads, sidebars, and boilerplate looks long but delivers almost nothing. Litmus now computes a substantive-sentence ratio: how many sentences contain actual information (numbers, proper nouns, specific claims) versus filler. Thin pages get flagged regardless of their other scores — because even a fresh, authoritative, well-structured page can be empty.
Syndication Detection
Wire services and content farms republish the same article across dozens of domains. Without syndication detection, your agent mistakes five copies of one story for five independent sources. Litmus identifies near-duplicate content and flags it so your agent knows when it's looking at a reprint, not a corroboration.
Paywall & Truncation Detection
Some pages lie about what they deliver. A paywalled article returns a teaser paragraph and a "subscribe to continue" prompt. Your agent, reading the markdown, doesn't know it's seeing 10% of the story. Litmus detects paywall gates, subscription prompts, and partial renders — and warns your agent when content is truncated.
Content-Type Classification
News, tutorial, product page, forum post, academic paper, documentation — Litmus classifies every page upfront. Before your agent reads a single word, it knows what kind of content to expect. A forum thread gets treated differently from a peer-reviewed paper, even if both mention the same topic.
The Token Math
A single parse without Litmus costs your agent roughly 5,000 reasoning tokens just to orient itself — figuring out what kind of source this is, whether it's current, which facts matter, whether to trust it. Those tokens don't produce output for the user. They're overhead.
With Litmus, those 5,000 tokens go to zero. The answers are already there. Your agent saves tokens, responds faster, and hallucinates less.
| Without Litmus | With Litmus | |
|---|---|---|
| Reasoning tokens per parse | ~5,000 | ~0 |
| Fact hallucination rate | 15-20% | <5% |
| Wrong source cited | ~25% of parses | ~2% |
Illustrative — actual token and accuracy impact depends on your agent model and prompt design. Litmus removes the need for your agent to do this reasoning itself.
What Firecrawl and Jina Don't Do
Firecrawl extracts content. Jina renders pages. Both give you markdown. Neither tells your agent anything about what that markdown means.
Litmus isn't a better scraper. It's a different category. Scrapers extract. Litmus interprets. Your agent can read Firecrawl's output. It can only reason with NanoParse's.
This isn't something Firecrawl can bolt on in a sprint. Their product is built for human developers who read markdown with their eyes. Litmus is built for agents that reason about content in context windows. Different consumer. Different output. Different product.
Zero Added Cost
Litmus runs in the same Worker CPU allocation as the parse. No LLM calls. No external APIs. No additional latency. Just regex, lookup tables, and heuristics — all computed at the edge.
Same price: $0.01 per parse. Same free tier: 10 free parses. No upgrade required. Litmus is in every response, by default, starting now.
Try It
curl -X POST https://nanoparse.app/fetch \
-H "Content-Type: application/json" \
-d '{"url": "https://en.wikipedia.org/wiki/Web_scraping"}'The litmus field is in every response. Your agent just got smarter. You didn't have to do anything.
NanoParse — Your agent deserves better data. nanoparse.app · Blog · MCP server