B.Tech CSE, VIT Vellore · CGPA 9.76 · 3rd Year · AI Research · Systems Design

The conversation that started everything

It began with a simple question: why can't AI understand common sense? Not the textbook answer — the real one. Why does a system that can write poetry and debug code completely fail when a person picks up a towel near a spilled glass of water?

I started thinking out loud. What if instead of discarding a low-confidence answer, the system stored it in chunks and used the failure to improve future related decisions? What if AI scored its own outputs against global human feedback and accumulated that as experience? What if we trained it on first-person video so it understood the physical world from the inside?

The ideas felt obvious. Turns out, "obvious ideas" that nobody has shipped yet are exactly what research labs spend millions trying to build.

One by one, each concept I described mapped directly to an active research frontier — some deployed at scale, some still unsolved. I hadn't read the papers. I hadn't taken an ML course beyond the basics. I had just thought carefully about the problem.

This post is the story of that thinking, what it maps to, and the working system I built from it.

6 research concepts independently derived · 17 tests passing in 0.43s · Phase 1 of 4 complete

The ideas — and what they actually are

I'm not claiming to have invented these. I'm claiming something more interesting: I derived them independently, from first principles, without reading the literature first.

The core insight: common sense is a scoring problem

The reason AI lacks common sense isn't mysterious. It's a specific, engineering-solvable failure: the system treats every observation as equally weighted, has no mechanism to score its own confidence against real-world feedback, and can't distinguish between "I know this well" and "I've seen one example of this once."

Humans do this automatically. When you see someone pick up a towel near a spill, you don't run an exhaustive search of every towel-related memory. You have a high-confidence rule — towel near spill means cleaning — and apply it instantly. If they wipe their face instead, your brain doesn't crash. It notes the contradiction, slightly updates the rule's confidence, and files the anomaly.

{% callout type="info" %} Key Insight: The gap between AI and human common sense is not a data problem. It's an architecture problem. The system needs confidence-weighted rules, mismatch detection, and a self-correction loop — not more training data. {% /callout %}

The architecture

The system is called a Dual-Process World Model. The flow:

The asymmetry is intentional — contradictions penalise by 0.07, confirmations reward by only 0.05. One real contradiction is more informative than one more confirmation. This mirrors Bayesian updates on prior-heavy distributions.

The implementation

Four files. Each does exactly one thing.

core/rule.py — Atomic unit of knowledge. Stores description, confidence score, evidence count, contradictions. Laplace-smoothed scoring prevents scores of exactly 0 or 1 from sparse data.

core/rule_db.py — Vector store using sentence-transformers (all-MiniLM-L6-v2). "Cloth wipes puddle" matches "towel cleans spill" because meaning is encoded geometrically. Cosine similarity over 384 dimensions.

core/threshold.py — System 1/2 switching based on rule confidence. Records outcomes, closes the feedback loop. Generates multi-branch predictions from top-k semantic matches.

core/mismatch.py (Phase 2 — in progress) — LLM judge that reads expected vs actual outcome and determines if a mismatch occurred. Replaces the last manually-set flag in the system.

The scoring math:

def reinforce(self, amount: float = 0.05) -> None:
    """Observation matched — reward slightly."""
    self.evidence += 1
    self.score = min(1.0, self.score + amount)

def contradict(self, amount: float = 0.07) -> None:
    """
    Penalise harder than evidence rewards.
    One contradiction is more informative than one more confirmation.
    """
    self.contradictions += 1
    self.score = max(0.01, self.score - amount)

def recalculate_score(self) -> None:
    """Laplace-smoothed ratio — prevents 0 or 1 from sparse data."""
    total = self.evidence + self.contradictions
    raw = (self.evidence + 1) / (total + 2)
    self.score = round(max(0.1, min(0.95, raw)), 3)

It ran. It worked. It self-corrected.

After seeding 6 rules and running 6 observations:

• "towel cleans water spill" score dropped 0.95 → 0.88 after one mismatch

• "towel wipes body sweat" correctly triggered DEEP mode (low confidence, 0.30)

• "robot arm + acid" escalated to HUMAN — no matching rule found

No manual labels. No hardcoded logic. Pure statistical self-correction. 17 tests pass in 0.43 seconds.

Build roadmap

What's still the open research problem

Every component here is real and running. What doesn't exist yet — anywhere — is a unified, real-time system combining all of them.

{% callout type="warning" %} The Honest Gap: Threshold scoring exists. Mismatch detection exists. Memory consolidation exists. Predictive coding exists. What the field is still missing is a single architecture that runs all four simultaneously in real time, on live input, without catastrophic forgetting. This system is the skeleton — the hard problems are in the connective tissue. {% /callout %}

Why I'm publishing this

Because ideas without timestamps don't exist. And because the most useful thing I can do for other students who think in systems but haven't connected those thoughts to the research literature is to show: the gap is smaller than it looks.

The difference between an idea and a contribution is the build log. So here is mine.

The repo goes public when Phase 3 ships. Until then, this post is the timestamp.

GitHub: coming at Phase 3 ·