A few weeks ago, FreshContext was easy to describe badly.
I could say:
FreshContext is an MCP server with 21 tools.
That was technically true.
It was also the wrong headline.
The more I kept building, testing, and trying to explain it to people, the more obvious the problem became: nobody really cares that a project has “21 tools” unless they already understand what those tools solve.
A user does not wake up thinking:
I need 21 MCP tools.
They think:
Can I trust this source?
Is this information still current?
Is this thing worth citing?
Is this job still fresh?
Is this package active or abandoned?
Is this study useful, or just old background?
Which context should my agent read first?
That is the product.
Not the tool count.
Here is the short visual explainer:
The old framing
The old FreshContext shape was:
21 MCP tools
→ fetch different kinds of information
→ stamp freshness metadata
→ return ranked context
Useful, but too implementation-shaped.
It made FreshContext sound like a plugin pack.
That creates the wrong questions:
Which tool do I use?
Why 21?
Do I need all of them?
Is this only for Claude?
Is this only MCP?
Those questions are a smell.
FreshContext should not be understood as a bag of tools. The tools are reference adapters. They prove the engine can handle different information classes: GitHub activity, social signals, academic papers, finance data, jobs, government records, company intelligence, and composite landscapes.
But they are not the product identity.
The new framing
FreshContext is becoming a context judgment layer.
The cleaner sentence is:
FreshContext turns raw retrieved information into freshness-ranked, explained, provenance-aware context.
The sharper sentence is:
FreshContext tells you whether a source deserves to be used, cited, refreshed, or ignored.
That is the actual lane.
The current architecture is moving toward this shape:
Raw candidate context
→ Source Profile
→ Core evaluation
→ ranked explanation
→ decision-ready context
The key phrase is decision-ready.
A raw score is not enough.
If FreshContext says:
Freshness: 16
Final score: 0.664
Utility: 14.006
Confidence: high
a normal person can fairly ask:
So what?
That is the next layer I am working toward.
The output should become more like:
Decision: Use as background
Meaning: This source is relevant and credible, but older than newer work.
Action: Use it for foundation, not as the latest evidence.
That is what makes it useful outside developer circles.
Source Profiles
The first step was separating source types from tools.
Different information ages differently.
A stock quote can go stale in hours.
A social launch signal can go stale in days.
A job listing can expire quickly.
An academic paper can remain useful for years.
Official documentation can be older than a blog post and still be more authoritative.
So FreshContext now has the idea of Source Profiles.
Examples:
official_docs
code_activity
social_pulse
academic_research
market_finance
jobs_opportunities
government_regulatory
company_intel
composite_landscape
local_custom
A Source Profile describes how a class of information should age, fail, rank, and explain.
That means the question is no longer:
Which of the 21 tools did this come from?
The question becomes:
What kind of source is this, and how should FreshContext judge it?
That is a better abstraction.
The first visible demo
There is now a local demo command:
npm run demo:evaluate
It takes hardcoded academic-style candidate sources and evaluates them through an academic research profile.
The current flow is:
raw candidate context
→ source profile policy
→ Core evaluation
→ ranked output
The demo shows a few important behaviors:
- a fresh, relevant academic source ranks first
- an older but still useful source remains usable
- a missing-date source is warned
- a failed or blocked source does not get treated as fresh
That last part matters.
A bad signal should not be dressed up as good context just because an agent needs an answer.
FreshContext is trying to be honest about uncertainty.
What this is not
FreshContext is not trying to become a legal advisor, medical advisor, tax advisor, or investment advisor.
That is not the promise.
The promise is smaller and more useful:
This source is current.
This source is stale.
This source is traceable.
This source has missing dates.
This source looks failed.
This source is worth reading first.
This source should be used only as background.
This source should be refreshed before being trusted.
That is citation and context judgment.
For example, in a research workflow, FreshContext should not say:
This medical conclusion is correct.
It should say:
This study may be relevant, but verify it against recent reviews, guidelines, and stronger evidence before relying on it.
That boundary matters.
Why this matters for agents
Most AI systems are limited by the quality of the context they receive.
If an agent receives stale, failed, irrelevant, or weakly sourced material, it can reason confidently from bad input.
FreshContext is meant to sit before that step.
retrieval results
tool outputs
notes
papers
docs
logs
links
↓
FreshContext
↓
ranked, explained, citation-ready context
↓
agent or human
This is why I am moving away from “tools marketing.”
MCP remains important. REST matters. SDK and CLI paths matter too.
But those are surfaces.
The center is Core.
Where this is going
The next layer is a decision layer.
Source Profiles answer:
What kind of source is this?
Intent Profiles will answer:
What is the user trying to decide?
A student asks:
Can I cite this?
Is this study still useful?
Is it background or current evidence?
A developer asks:
Is this package active?
Is the community responding well?
Is it worth testing?
A job hunter asks:
Is this job fresh?
Does it fit me?
Can I still apply?
A business user asks:
Is this market signal recent?
Is adoption visible?
Is this hype or substance?
Same Core.
Different intent.
The output should eventually become:
Decision: Cite as supporting
Decision: Use first
Decision: Needs verification
Decision: Refresh before using
Decision: Exclude
That is the practical layer.
The bigger shift
FreshContext started as an MCP project.
It is becoming a context infrastructure project.
The 21 tools are still useful, but they are no longer the headline.
They are proof surfaces.
The more durable product is:
standard input
standard evidence envelope
standard source profiles
standard decision labels
standard reasons and warnings
That can plug into agents, research workflows, student study tools, developer tooling, business analysis, and eventually larger systems that need context integrity before reasoning.
Current status
The latest clean milestone:
Core evaluation pipeline: working
Source Profile presets: working
Local REST handler: working
Local demo: working
MCP tools: still live
Worker runtime: untouched
No REST deployment yet
No npm publish change yet
The project is still early.
But the direction is clearer now:
FreshContext decides what context deserves to reach the model.
That is the product I am building toward.
Top comments (0)