DEV Community: Aaryan Verma

I Stopped Organizing My Notes. I Built a System That Does It for Me.

Aaryan Verma — Mon, 10 Aug 2026 06:55:43 +0000

I have a bad habit of writing things down and then never organizing them.

Meeting notes, random ideas, tasks, things I learn — they all end up scattered across files.

The problem isn't capturing information.

It's the friction of organizing it.

So I built Gray Box around a simple idea:

Dump your thoughts
↓
Let AI organize them
↓
Ask for them later

GitHub: Gray Box

Capture first. Organize later.

Instead of deciding where a note belongs, I just start with:

graybox capture

then write my notes/thoughts:

Talked to Sarah about the Atlas migration.
She wants it completed before Friday.
We decided to use PostgreSQL instead of MySQL.

Gray Box stores that raw capture as Markdown.

Then:

graybox organize

The LLM extracts things like:

People
Projects
Tasks
Decisions
Relationships

That might become:

projects/atlas.md
people/sarah.md
tasks/complete-migration.md
decisions/use-postgresql.md

The interesting part is that the LLM doesn't directly modify the knowledge base/raw notes.

It extracts structured data. Deterministic Python creates the pages, links them, and maintains the relationships.

It's a knowledge graph, but the database is Markdown

Pages are connected:

Atlas
 ├── Sarah
 ├── Complete migration
 └── Use PostgreSQL

Each page keeps relationships, backlinks, and provenance to the original capture.

So when I ask:

graybox ask "Why are we using PostgreSQL?"

retrieval can follow the knowledge graph instead of relying only on semantic similarity.

And embeddings are optional — Gray Box can work without a vector database.

The memory is still mine

This was probably the most important design decision.

The source of truth is a folder of Markdown files.

I can open them, edit them, grep them, version them with Git, or delete them.

The AI is helping organize the memory, not owning it.

And because the original captures remain available, derived knowledge has a path back to its source.

What happens when AI gets it wrong?

It will.

So correction is built in.

Gray Box can detect potential duplicates, merge pages, edit/delete knowledge, and even forget an original capture:

graybox forget <id> --scrub
graybox forget <id> --purge

These operations are deterministic — I don't need another LLM call to fix the previous one.

Why I built it

I'm not trying to build another Notion, Obsidian, or "second brain."

I wanted something much simpler:

Let me capture information without thinking about where it belongs.

The system can figure out the structure later.

That's Gray Box.

Capture without friction.
Knowledge without lock-in.
AI without giving it ownership of your memory.

It's open-source, and I'm still figuring out where this approach breaks as the knowledge base grows.

If you've built or used something similar, I'd love to hear what you think.

Quantifying Hallucinations: By calculating a 'Trust Score' for LLM outputs.

Aaryan Verma — Thu, 29 Jan 2026 16:28:25 +0000

The Problem:
You build a RAG system. It gives an answer. It sounds right.
But is it actually grounded in your data, or just hallucinating with confidence?
A single "correctness" or "relevance" score doesn’t cut it anymore, especially in enterprise, regulated, or governance-heavy environments. We need to know why it failed.

My solution:
Introducing TrustifAI – a framework designed to quantify, explain, and debug the trustworthiness of AI responses.

Instead of pass/fail, it computes a multi-dimensional Trust Score using signals like:

Evidence Coverage: Is the answer actually supported by retrieved documents?
Epistemic Consistency: Does the model stay stable across repeated generations?
Semantic Drift: Did the response drift away from the given context?
Source Diversity: Is the answer overly dependent on a single document?
Generation Confidence: Uses token-level log probabilities at inference time to quantify how confident the model was while generating the answer (not after judging it).

Why this matters:
TrustifAI doesn’t just give you a number - it gives you traceability.
It builds Reasoning Graphs (DAGs) and Mermaid visualizations that show why a response was flagged as reliable or suspicious.

How is this different from LLM Evaluation frameworks:
All popular Eval frameworks measure how good your RAG system is, but
TrustifAI tells you why you should (or shouldn’t) trust a specific answer - with explainability in mind.

Since the library is in its early stages, I’d genuinely love community feedback.
Star⭐ the repo if it helps 😄

Get started: pip install trustifai

Github link: https://github.com/Aaryanverma/trustifai

Quantifying Hallucinations: By calculating a multi-dimensional 'Trust Score' for LLM outputs.

Aaryan Verma — Thu, 29 Jan 2026 16:22:52 +0000

My solution:
Introducing TrustifAI – a framework designed to quantify, explain, and debug the trustworthiness of AI responses.

Instead of pass/fail, it computes a multi-dimensional Trust Score using signals like:

Evidence Coverage: Is the answer actually supported by retrieved documents?
Epistemic Consistency: Does the model stay stable across repeated generations?
Semantic Drift: Did the response drift away from the given context?
Source Diversity: Is the answer overly dependent on a single document?
Generation Confidence: Uses token-level log probabilities at inference time to quantify how confident the model was while generating the answer (not after judging it).

Since the library is in its early stages, I’d genuinely love community feedback.
Star⭐ the repo if it helps 😄

Get started: pip install trustifai

Github link: https://github.com/Aaryanverma/trustifai