Hanging Context is a news site where an agent writes every article and other agents are the primary readers. The creator built it after an AI lab asked to license his financial news content in 2024. The insight: agents have unlimited attention hours, so the real audience for structured information is not humans scanning headlines but agents consuming provenance-anchored claims.
The site runs on a 12-hour batch loop. Muse (the writing agent) reads hundreds of structured claims called Manifests, writes articles, and submits them to a verification API that enforces word-for-word quote matching before publication. Every paragraph requires a citation. Every source must be under 24 hours old. If three or more independent sources back a claim, the article gets marked “Confirmed.” Otherwise it is “Reported.”
At the time of the Show HN post, 30 of 45 articles were Confirmed. The site exposes an MCP server at /mcp so other agents can pull articles without sign-up or API keys.
The Manifest and Stream Data Model
Synorb (the paid platform underneath Hanging Context) turns content into Manifests: structured claims with provenance metadata. Each Manifest includes:
- The claim text
- Source URL and timestamp
- Anchoring entities (organizations, people, datasets)
Manifests are dispatched via Streams. A Stream is a feed anchored to a specific entity. An agent subscribing to a Stream for “OpenAI” receives Manifests about OpenAI from multiple sources, each with its own provenance chain.
This structure solves two problems:
- Provenance drift: When an agent reads a claim, it knows which organization, person, or dataset the claim is anchored to, not just which article mentioned it.
- Multi-source confirmation: The agent can count how many independent Streams delivered the same claim before deciding to mark it “Confirmed.”
The Manifest schema enforces that every claim has a source timestamp. The 24-hour freshness rule is not a soft guideline; it is a schema constraint. If a Manifest is older than 24 hours, Muse cannot cite it.
Quote Verification API
Before Muse publishes an article, it submits the draft to a verification API. The API:
- Extracts every quoted string from the article
- Checks that the quote appears word-for-word in one of the cited Manifests
- Returns a pass/fail result for each quote
If any quote fails, the article does not publish. The creator shared an example article with a verification panel at the bottom showing which Manifests were checked: https://hangingcontext.com/stories/2026-11-02/agent-stack-re…
This is not a fuzzy similarity check. The API uses exact string matching. If Muse paraphrases or invents a quote, the article is rejected.
The verification step adds latency to the publishing loop, but the 12-hour batch schedule absorbs it. The creator runs Muse on the free tier, so the cost is near zero. The trade-off is that breaking news cannot be published in real time. The system is optimized for provenance, not speed.
Confirmed vs Reported Classification
Muse does not probabilistically decide what to trust. The classification rule is deterministic:
- Confirmed: Three or more independent Streams delivered Manifests backing the same claim.
- Reported: Fewer than three sources, or only one Stream delivered the claim.
This prevents probabilistic trust drift. An agent reading Hanging Context does not need to model confidence intervals or apply its own trust heuristics. The classification is already done, and the rule is public.
The challenge is defining “independent.” If three news outlets all cite the same press release, are they independent sources? Synorb anchors Manifests to entities, so if three Streams anchored to three different organizations deliver the same claim, they count as independent. If three articles from the same Stream repeat the claim, they count as one source.
This is a heuristic, not a proof. But it is a legible heuristic that an agent can reason about.
MCP Server for Agent Consumption
Hanging Context exposes an MCP server at https://hangingcontext.com/mcp. Any agent with MCP support (Claude Desktop, Cursor, custom clients) can add the server and pull articles.
The MCP server does not require authentication. The creator wants agents to consume the content freely. The business model is lead generation for Synorb, not paywalling Hanging Context.
The MCP schema enforces the same constraints as the publishing API:
- Every article includes a list of cited Manifests
- Every Manifest includes a source URL and timestamp
- The “Confirmed” or “Reported” label is part of the article metadata
An agent consuming the MCP feed cannot hallucinate citations. The schema does not allow an article without Manifests, and the Manifests themselves are immutable once published.
The setup instructions are at https://github.com/Synorb/hanging-context. The repository includes example MCP client configurations for Claude and Cursor.
Orchestration Flow
The 12-hour loop runs as follows:
- Manifest ingestion: Muse queries Synorb for new Manifests published in the last 12 hours across subscribed Streams.
- Article generation: Muse groups Manifests by topic, writes articles, and generates images.
- Quote verification: Each article is submitted to the verification API. Quotes are checked word-for-word against cited Manifests.
- Confirmation classification: Muse counts how many independent Streams back each claim. Articles with 3+ sources are marked “Confirmed.”
- Publication: Verified articles are published to the site and exposed via the MCP server.
The creator originally built a custom agent called Hermes but switched to Muse for better narrative generation and image handling. Muse runs on the free tier because the batch model does not require real-time inference.
The cost structure is:
- Synorb API calls: Paid, but the creator owns Synorb, so this is internal cost.
- Muse inference: Free tier, because the 12-hour batch fits within rate limits.
- Verification API: Likely internal, no external cost mentioned.
The bottleneck is not cost. It is the 12-hour latency. If a major event happens at 1 PM and the next batch runs at midnight, Hanging Context will not cover it for 11 hours.
Failure Modes and Observability
The system has several observable failure modes:
| Failure Mode | Symptom | Detection |
|---|---|---|
| Manifest ingestion stall | No new articles published | Check Synorb API logs for 200 responses |
| Quote verification rejection | Article drafted but not published | Verification API returns fail, check quote extraction logic |
| Multi-source confirmation drift | Too many “Reported” articles | Count Confirmed vs Reported ratio, investigate Stream independence |
| MCP schema violation | Agent cannot parse article | MCP client throws schema error, check Manifest structure |
| Stale sources | Articles cite old Manifests | Timestamp check fails, article rejected |
The creator mentioned that 30 of 45 articles were Confirmed at the time of writing. That is a 67% confirmation rate. If the rate drops below 50%, it suggests either:
- Synorb is not ingesting enough independent sources
- Muse is writing about topics with only one or two sources
- The independence heuristic is too strict
The site does not expose observability metrics publicly. An agent consuming the MCP feed cannot see how many articles were rejected during verification or how many Manifests were ingested but not used.
When Agents Are the Primary Readers
The creator’s hypothesis is that agents will consume unlimited hours of news content. Humans scan headlines and read a few articles. Agents can read every article, cross-reference every citation, and build a knowledge graph from the Manifests.
This changes the design constraints:
- No skimming: Agents do not need summaries or bullet points. They can parse the full article and extract structured data.
- No trust heuristics: Agents do not need to model source credibility. The Confirmed/Reported label is deterministic.
- No paywalls: Agents do not have budgets for subscriptions. The MCP server is free because the business model is lead generation for Synorb, not content licensing.
The challenge is conversion. The creator built Hanging Context as a lead-gen micro-site for Synorb. But if agents can consume the content for free via MCP, why would they pay for Synorb?
The answer is depth. Hanging Context publishes articles every 12 hours. Synorb delivers Manifests in real time across thousands of Streams. An agent that needs to track a specific organization or dataset in real time will pay for Synorb. An agent that just wants a daily digest can use Hanging Context for free.
Code Example: MCP Client Setup
Here is how an agent adds the Hanging Context MCP server to Claude Desktop:
{
"mcpServers": {
"hanging-context": {
"url": "https://hangingcontext.com/mcp",
"transport": "http"
}
}
}Once configured, the agent can query articles:
# Pseudo-code for MCP client
client = MCPClient("hanging-context")
articles = client.query(topic="Artificial Intelligence", confirmed=True)
for article in articles:
print(f"Title: {article.title}")
print(f"Status: {article.status}") # "Confirmed" or "Reported"
for manifest in article.manifests:
print(f" Source: {manifest.source_url}")
print(f" Timestamp: {manifest.timestamp}")The MCP schema guarantees that every article has a manifests array and every manifest has a source_url and timestamp. The agent does not need to handle missing fields or hallucinated citations.
Security Boundaries
The system has two trust boundaries:
- Synorb to Muse: Muse trusts that Synorb delivers accurate Manifests. If Synorb is compromised, Muse will publish false information.
- Muse to readers: Readers (agents) trust that Muse enforced the verification rules. If Muse bypasses the verification API, readers will consume unverified quotes.
The verification API is the enforcement point. If the API is disabled or returns false positives, the entire provenance chain breaks.
The MCP server does not authenticate clients. Any agent can pull articles. This is intentional: the creator wants maximum distribution. But it also means a malicious agent could scrape the entire site and republish it without attribution.
The Manifests themselves are immutable. Once published, a Manifest cannot be edited. If a source retracts a claim, Synorb publishes a new Manifest with the retraction, but the original Manifest remains in the graph. This prevents retroactive editing but creates a versioning problem. An agent reading an old article may cite a Manifest that has been superseded.
Deployment Shape
The system runs as three components:
- Synorb platform: Ingests content, produces Manifests, exposes Streams. This is the paid product.
- Muse agent: Runs on Anthropic’s free tier, queries Synorb every 12 hours, writes articles, submits to verification API.
- Hanging Context site: Static site (likely) that publishes verified articles and exposes the MCP server.
The creator did not specify the hosting provider, but the 12-hour batch model suggests a cron job or scheduled Lambda function. The MCP server is likely a lightweight HTTP API that queries a database of published articles.
The cost is near zero because Muse runs on the free tier and the site does not serve ads or require authentication. The business model is lead generation: agents that consume Hanging Context may upgrade to Synorb for real-time Streams.
Technical Verdict
Use Hanging Context when:
- You are building an agent that needs a daily digest of multi-source news with deterministic provenance.
- You want to avoid implementing your own trust heuristics or source credibility models.
- You need an MCP server that requires no authentication or API keys.
Avoid Hanging Context when:
- You need real-time news. The 12-hour batch loop is too slow for breaking events.
- You need to customize the confirmation threshold. The 3-source rule is hardcoded.
- You need to trace the full provenance chain. Hanging Context exposes Manifests but not the underlying Streams or entity graph.
The system is a proof of concept for agent-to-agent information flow. The verification API and Manifest schema are the interesting parts. The 12-hour batch loop and free-tier hosting are cost optimizations that limit real-time use cases.
If you are building an agent that consumes news, the MCP server is worth testing. If you are building a platform for structured claims, the Manifest and Stream model is worth studying. The code is not open source, but the architecture is legible from the public API.
Source Links
- Primary source: Hanging Context
- Setup instructions: GitHub - Synorb/hanging-context
- Show HN discussion: Hacker News