Most RAG systems start with the same bet: split documents into chunks, embed the chunks, retrieve a few nearest neighbors, and let the model write over the top. That works when the question is simple and the source corpus is slow. It starts to break when the world is moving, sources disagree, and the answer depends on whether a claim is new, verified, directly quoted, measured, inferred, or stale.
The missing unit is not a bigger chunk. It is context.
For agents, context is not just "some text near the query." Context is the structured envelope around the text: who said it, when it was published, when it entered the system, which stream it belongs to, which entities it touches, what kind of claim it is, how strong the evidence is, and whether the public aggregate view supports the same direction.
That is the boundary Hanging Context and Synorb are built around. Hanging Context gives public aggregate reasoning panels and JSON twins. Synorb is the retrieval and detail layer where a customer agent can ask for manifests, signals, briefs, records, and stream-specific delivery.
Technical thesis
RAG needs an object model, not only a vector index. The retrieval layer should return text with enough surrounding structure for policy to run before generation:
- A record identifies the source material and preserves provenance.
- A signal carries the extracted claim structure.
- A brief gives a narrative form that can be read or summarized.
- A manifest binds source, signal, brief, stream routing, timestamps, and stable IDs into one delivery object.
- A public panel exposes aggregate shape and sample claims without exposing the full retrieval layer.
That separation matters because production agents should not ask a model to infer provenance, freshness, and confidence from prose. Those fields should arrive as data.
The chunking problem
A chunk can tell an agent that a source mentioned a company, an economic release, or a product. It usually cannot tell the agent whether the sentence is a forecast, a disclosure, a quote, a boilerplate disclaimer, or a stale re-publication of an older page.
That distinction matters.
The checked-in Hanging Context schema makes this visible. `hangingcontext/data/schema.json` documents fields such as `evidence_types`, `confidence_levels`, `verified_samples`, `top_sources`, `top_streams`, `stream_filter_shapes`, and `domain_freshness`. Those are not decorative analytics. They are the context fields an agent needs before it decides what to trust, what to cite, and what to fetch next.
A raw chunk says:
This text appears in a source.
A context object says:
- This claim came from this source URL.
- It was published on this date.
- It was verified or ingested at this time.
- It has this confidence level.
- It uses this evidence type.
- It belongs to these streams.
- It can be joined back to a stable claim, record, stream, or tag ID.
That is a different substrate.
What Hanging Context shows publicly
Hanging Context exposes the public side of this pattern. The homepage declares JSON alternates for `/data/windows/7d.json`, `/data/windows/24h.json`, and `/data/index.json`. The catalog in `hangingcontext/data/index.json` records `schema_version`, `as_of`, time ranges, and top-line totals for the rolling windows. The monthly artifacts add longer-lived aggregate examples.
For example, `hangingcontext/data/months/2026-04.json` includes April 2026 fields for claims by day, top sources, top streams, evidence types, confidence levels, domains, highlights, and samples. A RAG system that can see those fields can reason differently from one that only sees paragraphs.
It can ask:
- Is this claim fresh relative to the current window?
- Does the domain-level aggregate support the answer I am about to give?
- Which source channels are overrepresented?
- Are the claims mostly direct quotes, paraphrases, observed facts, or derived conclusions?
- Are there public sample claims I can cite while reserving private detail retrieval for Synorb?
Those are context questions. They are not chunk questions.
Where Synorb begins
The detail layer lives in Synorb. The local REST payload code in `deliver/channels/rest_api.py` describes manifest access as a triplet: source metadata, signal, brief, and record. `deliver/shared_manifest.py` joins manifest rows to records, signal stories, brief stories, source channel display names, stream IDs, and routing timestamps.
That shape matters because it separates jobs:
- The signal is the structured claim extraction layer.
- The brief is the human-readable narrative layer.
- The record is the source-material layer.
- The manifest envelope gives stable IDs, stream routing, and timestamps.
RAG systems often blur these layers together. They retrieve a passage and ask a model to infer the rest. Synorb keeps the layers explicit so agents can choose the right depth for the task.
If an agent is writing a public answer, the Hanging Context panel may be enough: aggregate counts, examples, and public schema. If an agent is making a customer-specific decision, it can retrieve the Synorb manifest or record through the paid detail layer.
A grounded example
In `hangingcontext/data/months/2026-04.json`, one public sample claim says the U.S. Department of Labor issued a proposed rule and related news release. The same sample carries `source_url`, `published_date`, `evidence_type`, `confidence`, and `domain`. That is already more useful to an agent than a free-floating text chunk.
The claim text is modest. The structure is the point.
An agent can decide that a society-law-government claim with stated confidence and a source URL is eligible for a compliance summary. It can also decide that the source record is needed before taking action. The public HC artifact gives the aggregate context; Synorb is where the deeper retrieval happens.
The takeaway
RAG does not need more text by default. It needs better context objects.
Chunks are useful when the world is static and the model only needs a quotation. Agents need more. They need temporal context, source context, evidence context, stream context, and stable IDs. Hanging Context makes the public aggregate layer visible. Synorb supplies the retrieval and detail layer behind it.
That is the difference between a search result and context for AI.