u/Appropriate_West_879

Ran this query against our production endpoint today:

topic: "multi-agentic ai orchestration"
difficulty: 4
formats: ["pdf", "github"]

https://preview.redd.it/z99msh8lro2h1.png?width=1860&format=png&auto=webp&s=66dcca7e148a8e3f86f1f01a8f404ca8e1d25a09

Here is what the decay scoring returned on 6 sources:

arxiv:2505.02861v2    decay: 0.214  label: fresh    age: 381 days
github:harmonist      decay: 0.015  label: fresh    age: 4 days  
arxiv:2601.14652v4    decay: 0.072  label: fresh    age: 118 days
github:win4r/tasks    decay: 0.317  label: aging    age: 99 days  ⚠️
arxiv:2601.10560v1    decay: 0.075  label: fresh    age: 123 days
github:builderz-labs  decay: 0.306  label: aging    age: 95 days  ⚠️

https://preview.redd.it/350gtunmro2h1.png?width=1860&format=png&auto=webp&s=8d3ce2f6d53440b2cf1a1e8937f7ae64848f6189

Two sources flagged as aging — not stale enough to block, but enough to warn the downstream LLM before synthesis.

Knowledge velocity: STABLE — median source age 108 days, quarterly refresh recommended.

The problem this solves: standard RAG has no concept of time. A GitHub repo last updated 99 days ago scores identically to one updated yesterday if the semantic similarity is high. For fast-moving domains like agentic AI, that is a silent quality problem.

We built a post-retrieval decay gate that stamps every retrieved document with a freshness score before it enters the LLM context window. The math:

decay = 1 - 0.5^(age_days / half_life_days)

Half-life varies by source type — GitHub repos decay faster than arXiv papers.

Free tier — 500 calls/month, no credit card: https://api.knowledgeuniverse.tech

Signup takes 30 seconds. Your key arrives instantly.

How are others handling temporal staleness in production RAG pipelines? Curious if this is a solved problem I missed or if people are building workarounds.

Been working on the context rot problem in enterprise

RAG for a while. Standard vector retrieval has no

concept of time — it measures semantic similarity,

not temporal relevance.

Ran a test query today: "best practices for deploying

LLM agents in enterprise environments"

Here's what came back:

- A regulatory compliance paper: 265 days old,

decay score 0.395, labeled "aging", 55 days until

it goes stale, penalty multiplier 0.742

- A paper published yesterday: decay score 0.002,

freshness 0.998

- Knowledge velocity: "Field is moving fast.

Refresh your index every 21 days."

Your LLM sees both documents. It cannot tell which

one to trust. Mine can.

The API calculates domain velocity, applies

authority-weighted exponential decay, and returns

a days_until_stale integer on every retrieved chunk

before it hits the LLM. No LLM in the scoring layer.

Pure math. Fully auditable.

Happy to share the endpoint if anyone wants to run

it against their own queries.

What's your current approach to handling temporal

relevance in retrieval? Curious how others are

solving this.

Anyone else struggling with vector databases returning incredibly confident, but temporally stale data?

Semantic similarity is great, but in domains like clinical NLP or Fintech, a 0.95 similarity match on a 3-year-old superseded clinical guideline just forces the LLM to hallucinate.

I’ve been architecting a temporal routing layer that sits between the Vector DB and the LLM. It calculates a deterministic decay_score based on source age, domain velocity, and conflict detection.

I spun up a quick Streamlit sandbox so you can test how fast your specific domain is rotting. Just drop an arXiv title or topic in to see the half-life TTL.

Test it here:https://ku-freshness-engine-fwsxfw7up2x9txshqcydf9.streamlit.app/

Would love some brutal feedback on the decay math from anyone building high-stakes agents.