EVIDENCE

EVIDENCE is an agent-native empirical research environment powered by WebMCP, enabling AI agents to inspect data, run analyses, test hypotheses and distinguish evidence from unsupported causal claims.

Comment

Inspiration

EVIDENCE started with a question I kept coming back to while using AI for research:

How do we know that an AI's answer is actually supported by the evidence?

I noticed how easily an AI can move from a few observations to a confident explanation. That becomes a serious problem when working with real-world data, especially economic data.

While investigating whether construction activity changed Kenya's economic growth, I realized that observing two variables moving together does not mean that one caused the other.

If construction changes by (\Delta C) and GDP changes by (\Delta GDP), we might observe:

$$ \Delta C > 0,\qquad \Delta GDP > 0 $$

But that does not automatically establish:

$$ C \rightarrow GDP $$

The first statement is an observation. The second is a causal claim.

That distinction inspired EVIDENCE.

I wanted to experiment with an AI research environment where the agent has to interact with evidence, distinguish observations from inferences, recognize uncertainty, and avoid turning weak evidence into strong conclusions.

What it does

EVIDENCE is an agent-native research laboratory.

Instead of treating research as:

$$ \text{Question} \rightarrow \text{Answer} $$

EVIDENCE treats it as a process:

$$ Q \rightarrow E \rightarrow O \rightarrow I \rightarrow U \rightarrow C $$

where:

  • (Q) = research question
  • (E) = evidence
  • (O) = observation
  • (I) = inference
  • (U) = uncertainty
  • (C) = conclusion

The agent can interact with structured evidence tools and update its understanding of the investigation as new information becomes available.

I think of the research process as a changing state:

$$ S_{t+1} = f(S_t,A_t,E_t) $$

where (S_t) is the current research state, (A_t) is the agent's action, and (E_t) is the evidence returned by the environment.

This means the agent is not simply generating an answer. It is navigating a research state.

Most importantly, EVIDENCE allows insufficient evidence to remain a valid outcome.

How we built it

I built EVIDENCE as a web application using React, Vite, JavaScript, and WebMCP.

I started with the research interface and gradually built the agent interaction around structured tools.

The main idea was to expose capabilities that allow an agent to inspect evidence instead of simply giving the agent a large block of information and asking it to summarize everything.

The workflow became roughly:

$$ \text{Research Question} \rightarrow \text{Tool Action} \rightarrow \text{Evidence} \rightarrow \text{Updated State} $$

I also used real economic data while developing the concept, which helped me test the difference between what the data directly shows and what an AI might be tempted to conclude from it.

For example, correlation can be expressed as:

$$ r = \frac{\operatorname{Cov}(X,Y)} {\sigma_X\sigma_Y} $$

A strong correlation can tell us that two variables move together, but it does not by itself prove:

$$ X \rightarrow Y $$

That principle influenced both the research methodology and the architecture of EVIDENCE.

Challenges we ran into

The hardest challenge was not building the interface. It was deciding how an AI should reason about evidence.

It is easy to make a system that produces a convincing paragraph. It is much harder to make one that recognizes when the evidence is insufficient.

I also encountered several technical challenges during development:

  • Vite development-server and Hot Module Replacement issues
  • Port conflicts
  • Import and configuration errors
  • API authentication problems
  • Environment-variable issues
  • Iterating on the research interface
  • Understanding how WebMCP should fit into the application
  • Designing tools that are useful to both humans and AI agents

One thing that helped me was applying the same state-based thinking to debugging.

Instead of asking only:

"What is broken?"

I started asking:

$$ \text{What state is the system in?} $$

$$ \text{What changed?} $$

$$ \text{What caused the transition?} $$

That changed the way I debugged the application.

Accomplishments that we're proud of

I'm proud that EVIDENCE became more than an AI interface.

I managed to turn an idea about evidence-based reasoning into a working agent-oriented research environment.

I'm especially proud of three things.

First, the research model.

The system explicitly separates observations, evidence, inference, uncertainty, and conclusions.

Second, the agent interaction.

I experimented with WebMCP to move beyond the traditional chatbot model and make the web application an environment that an AI agent can interact with.

Third, the philosophy behind the project.

I deliberately designed the system around the possibility that the correct answer can be:

The available evidence is not sufficient to establish the claim.

For me, that is more valuable than producing an impressive answer that the evidence cannot support.

What we learned

The biggest lesson I learned is that answer generation and research are different problems.

An AI can be extremely good at producing plausible explanations while still making unsupported jumps between evidence and conclusions.

Building EVIDENCE made me think about research as a dynamic process.

If the current research state is (S_t), then new evidence can change it:

$$ S_{t+1} = f(S_t,E_t) $$

Sometimes the new evidence increases confidence:

$$ K_{t+1} > K_t $$

Sometimes it should decrease confidence:

$$ K_{t+1} < K_t $$

A good research agent therefore shouldn't always become more confident.

It should become better calibrated to the evidence.

I also learned that WebMCP changes how I think about web applications. A website can become more than something an AI reads. It can become an environment containing tools that an agent can discover and use.

What's next for EVIDENCE

The current version is a foundation.

Next, I want to make the research process more rigorous and more auditable.

Some of the things I want to build include:

  • Statistical analysis tools
  • Time-series analysis
  • Causal inference tools
  • Automatic contradiction detection
  • Source and evidence provenance
  • Hypothesis testing
  • Reproducible research traces
  • Research-state visualization
  • Stronger agent evaluation
  • More WebMCP-native capabilities

I would also like to represent the investigation as an evidence graph:

$$ G=(V,E) $$

where (V) contains observations, datasets, hypotheses, assumptions, and conclusions, while (E) represents relationships such as support, contradiction, and dependency.

The long-term goal is to make it possible to look at an AI's research process and ask:

What did it observe?

What did it infer?

What evidence changed its mind?

Which assumptions did it make?

And how strong is the final claim?

That is the direction I want to take EVIDENCE: from an AI that simply answers questions toward an AI that can show the path from evidence to knowledge.

Built With

Share this project:

Updates

Submission history