Proof

Inspiration

Most self-improvement products assume people need more advice.

But when a plan fails, the problem usually isn’t a shortage of advice. It’s that we chose the wrong explanation for what was happening. We say things like:

“I avoid important work because I lack discipline.”

Then we treat that belief as a fact—and ourselves as the problem.

Proof began with a different mental model:

Life is a series of experiments, not a series of verdicts.

Instead of acting like an all-knowing coach, Proof treats every explanation as a hypothesis. It proposes a tiny experiment, observes what actually happens, and updates its understanding over time.

What it does

Proof is a personal learning loop that gets more useful with every check-in.

A user describes something happening in their life. Proof then:

Generates three competing explanations.
Selects the explanation best supported by current evidence.
Records a falsifiable prediction.
Proposes one tiny behavioral experiment.
Collects the user’s real-world reflection.
Updates the confidence of every hypothesis.
Promotes, weakens, or replaces explanations before designing the next experiment.

For example, a user might begin with:

“I avoid important work because I lack discipline.”

Proof may initially suspect task ambiguity. It predicts that making the first action visible will make starting easier.

The user returns and says:

“I started, but Slack interrupted me.”

That evidence contradicts the original story. The user was able to start; momentum was lost afterward. Proof lowers confidence in the previous explanation, promotes interruption sensitivity, and proposes a new experiment: protect five notification-free minutes and observe whether momentum survives.

The goal is not to maximize streaks or compliance. It is to help people replace self-criticism with increasingly accurate self-understanding.

How I built it

Proof has three meaningful infrastructure layers:

Zero.xyz — competing reasoning

Zero generates the initial set of competing hypotheses and updates them when new evidence arrives. Every successful reasoning interaction returns a traceable Zero run ID.

Zero is not used to produce generic coaching copy. Its role is to maintain uncertainty, consider alternatives, and revise confidence based on evidence.

Akash — the persistent loop agent

The agent runs as a Node.js service on Akash.

It owns the actual loop: selecting the strongest hypothesis, recording a prediction, choosing the corresponding experiment, observing the next result, and advancing the user’s state.

This makes Akash more than a place to host an API. It runs the persistent decision-making process that turns separate AI responses into a self-correcting agent.

Pomerium — the private agent boundary

The Akash agent is not exposed directly to the public application.

Requests pass through a Pomerium-protected route. Pomerium verifies the application’s service identity and forwards a signed identity assertion to the private agent.

The interface only displays the complete Pomerium → Akash → Zero execution trace when the protected agent has genuinely completed the loop. If the remote capability is unavailable, Proof falls back safely and labels the result honestly.

The product interface is a responsive web application with simple account authentication, guided onboarding, persistent check-in history, competing-hypothesis views, confidence changes, predictions, experiments, and an ongoing model of what Proof is learning.

Challenges I faced

The hardest challenge was making the sponsor integrations essential rather than decorative.

An early architecture made several sequential reasoning calls during each interaction. It worked locally, but production requests exceeded the protected gateway’s response window. The application correctly fell back to its local safety loop—but that meant the real agentic work was not visible.

I redesigned the responsibilities:

Zero generates or updates the complete hypothesis set in one focused reasoning call.
Akash performs selection, prediction, and loop advancement.
Pomerium protects the boundary between the application and the agent.

This reduced production interactions from roughly 30 seconds to approximately 7–18 seconds while making each sponsor’s role clearer and more meaningful.

Another challenge was making uncertainty understandable. Raw model output is easy to hide inside conversational text, but that would make Proof look like another chatbot. I built a visible hypothesis arena showing what the system currently believes, why one explanation was selected, what it predicts, and exactly how confidence changes after new evidence.

What I learned

I learned that a genuine agent loop is not created by adding more model calls.

It comes from maintaining state across time:

[ \text{belief} \rightarrow \text{prediction} \rightarrow \text{experiment} \rightarrow \text{evidence} \rightarrow \text{updated belief} ]

The prediction is especially important. Without it, the system can reinterpret any outcome as proof that its original advice was correct. Recording the prediction makes the agent accountable to reality.

I also learned that “failed” experiments often produce the most useful evidence. Proof should never punish someone because an experiment did not work. The failure may simply reveal that the system’s explanation was wrong.

What I’m proud of

Proof visibly changes its mind.

It does not merely generate a different answer after receiving a new prompt. It preserves competing explanations, compares its prediction with reality, updates confidence, and allows a previously weak hypothesis to become the new leader.

That creates a much healthier relationship with self-development:

You are not the failed experiment.
The experiment is allowed to fail—and teach you something.

What’s next

The next step is to make Proof increasingly longitudinal.

Future versions could identify patterns across weeks, notice when the same mechanism appears in different parts of life, and suggest experiments based on what has previously worked for that individual.

The long-term vision is not an AI that tells people who to become.

It is an AI that helps people become more accurate, curious scientists of their own lives.

Built With

agentic-ai
ai-agents
akash-network
cloudflare-d1
cloudflare-workers
docker
drizzle-orm
github
jwt
llm
loop-engineering
next.js
node.js
pomerium
pomerium-zero
react
rest-api
typescript
zero.xyz