DEV Community: Devansh

The Ghost That Moves Your Money: Making an RL Payment-Retry Agent Accountable

Devansh — Wed, 28 Oct 2026 02:24:57 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

HRA-Pay is a reinforcement learning system that decides what to do after a payment fails: retry or give up, when to retry, and on which rail (UPI, credit, debit, netbanking, wallet).

Most retry systems use a supervised classifier that predicts a success probability. HRA-Pay treats the whole retry sequence as a Markov Decision Process. A branched Q-network learns a policy over timing and channel jointly, and a deterministic guardrail layer sits between that policy and any action that moves money.

How I read the theme: every learned policy is a ghost in the machine, an opaque decision-maker acting on your money that nobody can fully inspect. This project is about making that ghost accountable. The learned policy proposes, a rule-based guard (not AI, on purpose) disposes, and an audit trail records both what the ghost wanted to do and what it was allowed to do. I'll admit this project wasn't built for this theme. But the question the theme asks, "what do we do about the thing acting inside the system that we can't fully see?", is one the project spends most of its design effort on.

Code

23f3003672 / hra-pay

HRA-Pay

Hierarchical reinforcement learning for payment retry optimisation, with LLM-calibrated reward shaping.

Razorpay Buildathon 2026 — Track 03, AI Revenue Recovery

When a payment fails, a merchant faces a compound decision, not a single one retry or give up, when to retry, and on which rail. Production retry systems generally answer only the first two, with a supervised classifier that predicts a success probability. HRA-Pay treats the whole retry sequence as a Markov Decision Process and learns an explicit policy over timing and channel jointly — with a deterministic guardrail layer between the learned policy and any action that moves money.

python -m venv .venv && .venv\Scripts\activate     # Windows
pip install torch --index-url https://download.pytorch.org/whl/cpu
pip install -e ".[dev]"

python tasks.py test        # 91 tests
python tasks.py eval        # reproduces every number below
python tasks.py demo        # the dashboard

Results

1,000 episodes per run…

View on GitHub

python -m venv .venv && .venv\Scripts\activate
pip install torch --index-url https://download.pytorch.org/whl/cpu
pip install -e ".[dev]"

python tasks.py test    # 91 tests
python tasks.py eval    # reproduces every number in the README
python tasks.py demo    # the dashboard

How I Built It

Open-source stack: PyTorch (CPU), Gymnasium, NumPy, and Streamlit. Both learned agents are trained from scratch locally, with no pretrained weights and no hosted inference.

Decision policy: a Branching Dueling Q-Network (Tavakoli et al., 2018) with three branches: macro action {RETRY, SWITCH_CHANNEL, ABANDON}, timing {NOW, +2h, +6h, +24h, +72h}, and channel. Output size grows additively (13 outputs vs 31 for a flat head). I compared it against a flat dueling DQN and two static baselines, all through one shared Policy interface, runner, guard, and audit log.
Reward calibration: a language model reads each raw decline-reason string, and nothing else, and scores how much friction a retry carries. It runs once, offline, and the output is cached in a committed penalty_table.json. The numeric success probabilities never enter the prompt, and a test asserts it. The table refuses to load until a human reviews it, and the review overrode the model on three of the codes.
Guardrails: PolicyGuard is deterministic. It hard-blocks suspected_fraud (compliance), blocks futile retries, caps attempts, and escalates retries that come too soon. No Q-value can override it.
Environment: a seeded, synthetic simulator defined by fully commented YAML specs, plus a held-out spec that inverts the relationships an agent is most likely to have learned.

The language model used for calibration was Gemini (gemini-3.7-flash), a closed API. It's the one non-open component, but it's a one-time offline step and its output is a plain JSON file in the repo. Reproducing or replacing it with an open-weight model doesn't touch the training loop.

Results (1,000 episodes, learned agents averaged over 3 seeds):

policy	recovered ₹ (train)	recovered ₹ (held-out shift)
bdq (branched)	1,015,730 ± 41,732	765,171 ± 46,101
flat_dqn	1,003,601 ± 20,949	844,508 ± 22,809
static_with_switch	880,377	753,958
static_schedule	536,078	381,354

Issuer-risk exposure was zero in every run. I also report what counts against the system: the learned agents spend more retries, BDQ is slower to recovery than the naive baseline, and the BDQ-vs-flat ranking flips under distribution shift. On the training distribution the two architectures are statistically indistinguishable, and the comparison tool says so instead of declaring a winner.

Why Does Open Innovation Matter?

For a system that moves money, "trust me" is not an acceptable answer. Open innovation made three things possible that a closed API wouldn't have:

Inspectability end to end. The environment, the reward, the guard, and the metrics are all readable code and committed YAML. A reviewer can dispute the ground-truth assumptions directly, which matters when the main objection to this project is "you wrote both the environment and the agent."
Training and owning the policy. Because the decision model is a small network trained locally, I could checkpoint it, test it, run 3-seed comparisons, and stress-test it on an adversarial held-out distribution. A hosted model behind an API would give me none of that control.
Reproducibility as a feature. The environment and static baselines reproduce bit-identically across Windows and Linux. The neural parts don't, because torch seeding differs across builds, so the README reports mean ± std and states conclusions as gaps rather than digits.

It also shows in the one place I used a closed model. Because its output is cached and human-reviewed in the open, the closed API only touches the project where I could audit it.

The Spirit of It

The moment that made the "ghost" real for me was a number I almost skipped. In the results table, one baseline's mean time-to-recovery was exactly 24.00h. That's too round to be natural. It turned out the guard was silently crippling the baseline: the original failed authorisation was eating half of every channel's retry budget. I had handicapped the baseline my own agent had to beat, in the direction that flattered my agent.

Nothing crashed and no test failed. The system was just quietly wrong in my favour. That's the lesson I took from this project: the ghost isn't only the model. It's also the assumptions you wrote into the machine and stopped looking at. The repo keeps an ENGINEERING_LOG.md of this and other failures, including a flat-vs-branched comparison that was rigged by exploration and a comparison tool that confidently named the loser as the winner.

I Got Tired of Checking 15 AI Sites Every Morning, So I Built a Pipeline That Does It While I Sleep

Devansh — Sat, 24 Oct 2026 02:37:35 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Global Intelligence Graph is a data ingestion engine that keeps an eye on the AI world so I don't have to.

Staying current in AI means opening arXiv, Papers with Code, GitHub, a handful of news sites and several job boards, then copy-pasting the interesting bits somewhere. I dreaded that chore, so I automated it. One command now:

Scrapes research: the latest AI papers from arXiv and Papers with Code, plus GitHub star counts for papers that have repos.
Finds startups and products: it queries the GitHub API for repositories and extracts startup and product entities from them.
Reads the news: it pulls articles from 5 major AI news sources and keeps only those published in the last 24 hours.
Watches the job market: it scrapes 5 AI job boards with Playwright and converts relative dates ("3 hours ago") into absolute ISO timestamps, again keeping only the last 24 hours.
Cleans up the mess: it resolves entity names against a canonical dictionary using fuzzy matching, so "Open AI" and "OpenAI" become one entity.
Hands over tidy data: everything lands in SQLite and is exported as structured CSVs in output/.

Anyone who tracks the AI ecosystem (students, researchers, recruiters, founders) gets to be a little lazier: the morning tab-hopping becomes opening a folder of CSVs.

Code

23f3003672 / data-ingestion-engine

Global Intelligence Graph: Data Ingestion Engine

This repository contains the data ingestion pipeline for the AI Engineer demo task. It is designed for massive bulk extraction, 24-hour freshness tracking, and resilient LLM extraction using a multi-tier fallback architecture.

Setup Instructions

Python Environment: Ensure you have Python 3.11+ installed.

Install Dependencies

pip install -r requirements.txt
playwright install

Configure Environment Variables: Open the .env file in the root directory and add your API keys:
```
GEMINI_API_KEY=your_gemini_key
GROQ_API_KEY=your_groq_key
DEEPSEEK_API_KEY=your_deepseek_key
```
(Note: You can run the pipeline with just one of these keys, but the fallback chain works best when all three are present.)

Running the Pipeline

To execute the pipeline:

python src/main.py

Pipeline Flow

Phase I (Arxiv, Papers with Code & GitHub): Scrapes the latest AI research papers from Arxiv and Papers with Code. Queries the GitHub API for repositories to extract Startup and Product…

View on GitHub

How I Built It

The pipeline runs in four phases:

Phase I, research and GitHub. Scrapers collect papers from arXiv and Papers with Code. The GitHub API supplies repositories (the source of startup and product entities) and star counts.
Phase II, news and jobs. News articles are fetched from 5 sources. Job listings come from 5 JavaScript-heavy boards, so I used Playwright to render them.
Phase III, LLM extraction. An LLMExtractor turns messy raw payloads into validated Pydantic models. It also enforces the 24-hour freshness rule, so stale items never reach the database.
Phase IV, entity resolution. Company names across startups, products and jobs are normalized with fuzzy matching against a canonical dictionary.

Results are stored in an intermediate SQLite database (data_ingestion.db) that preserves relationships and raw payloads, then exported to CSV.

The multi-tier LLM fallback

Free-tier LLM APIs hit 429 rate limits constantly when you're doing bulk extraction. Rather than crash or pay for a bigger plan, the extractor falls back across providers:

Gemini → Groq (Llama 3) → DeepSeek

If one provider rate-limits, the next takes over, and a 5-second processing delay keeps the load gentle. You can run it with just one key, but it's most resilient with all three. Two of the three tiers are open-weight model families (Llama 3 and DeepSeek), so the extraction layer is not tied to a single closed vendor.

pip install -r requirements.txt
playwright install
python src/main.py

Why Does Open Innovation Matter?

Bulk extraction is exactly where closed APIs hurt: thousands of small calls, strict quotas, and a bill that grows with every page scraped.

No single point of failure. Because Llama 3 and DeepSeek are open-weight, many providers can serve them. My pipeline can swap models and hosts without rewriting the extraction logic, and a rate limit on one provider is a detour, not an outage.
Cost stays near zero. Open-weight models on free or cheap tiers let me run a daily pipeline without a subscription.
Swappable by design. The fallback chain is just an ordered list. Adding a locally hosted open-weight model (for example through Ollama) as another tier, or the first one, is a small change that would make the pipeline work fully offline with no data leaving my machine.
Open tools all the way down. Playwright, SQLite, Pydantic and the GitHub and arXiv ecosystems are all open, which made the whole thing easy to build and inspect.

ToxiLens: The Offline Molecular Safety Screener That Says "I Don't Know"

Devansh — Sun, 18 Oct 2026 09:03:22 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

A calibrated in-silico toxicology screener built for indie cosmetic formulators, clean-beauty artisans, and botanical fragrance creators who cannot afford a $50,000/year enterprise chemistry license or a $250/hour toxicologist.

What I Built

The Real Problem for Real People

Independent cosmetic chemists, natural perfumers, and botanical soap artisans face a massive barrier to entry: safety compliance and toxicological validation.

Before bringing an organic face oil, cold-process soap bar, or custom botanical candle to market, formulators must prove their candidate ingredients are non-sensitizing, non-carcinogenic, and compliant with strict international cosmetic regulations (such as EU Annex III).

Today, they are trapped between three flawed options:

Enterprise In-Silico Chemistry Suites (e.g., Derek Nexus, Leadscope): These cost $30,000 to $60,000 per seat per year, accessible only to multi-billion-dollar pharmaceutical and multinational personal-care conglomerates.
Contract Testing Wet-Labs: Commissioning an in-vitro toxicology screening panel costs $8,000 to $15,000 per compound and takes 6 to 8 weeks. If a candidate formulation turns out to be an endocrine disruptor or reactive sensitizer, that budget is lost.
Generic Commercial LLMs (ChatGPT / Claude): Formulators try pasting chemical names or SMILES into generic chatbots, but general-purpose LLMs notoriously hallucinate stereochemistry, invent nonexistent metabolic pathways, and give falsely confident reassurance on hazardous molecules.

The Solution: ToxiLens

ToxiLens is a private, lightweight molecular safety screener built entirely on open-source AI and cheminformatics foundations:

12 Calibrated Machine Learning Models trained on the National Institutes of Health (NIH) Tox21 benchmark dataset.
Split Conformal Prediction: Unlike ordinary ML models that output misleadingly confident probabilities (e.g., 0.51), ToxiLens produces mathematically guaranteed prediction sets at a user-selected 90% confidence level. When a molecule falls into an uncharted chemical space, it explicitly outputs "Uncertain / Refusal (I don't know)".
EU Annex III Allergen Matcher: Automatically scans against the European Commission's restricted fragrance and cosmetic allergen registries (e.g., Cinnamaldehyde, Citral, Coumarin).
Structural Alerts (Toxicophore Engine): Scans for reactive SMARTS patterns (Michael Acceptors, Epoxides, Nitroaromatics, Aromatic Amines).
Local Substructure Attribution & Vector Visualizer: Highlights exactly which atomic centers triggered an alert and displays nearest historical precedents from the Tox21 lab database.

Who Would Pay For It?

Indie Cosmetics & Fragrance Formulators: A $29–$49/month micro-SaaS tier (or $5 pay-per-screen audit) saves them thousands of dollars in wasted contract lab testing.
Specialty Chemical Consultants & Formulation Labs: They can run ToxiLens completely offline on their own hardware, guaranteeing that proprietary, patent-pending formulas never touch external cloud servers.

Demo

🌐 Live Web Application: https://toxilens.onrender.com
💻 Interactive REST API Docs: https://toxilens.onrender.com/docs
📦 GitHub Repository: https://github.com/23f3003672/ToxiLens

Conformal Calibration Proof

The plot below demonstrates that the empirical test coverage strictly matches nominal mathematical confidence across all calibrated confidence intervals:

Code

23f3003672 / ToxiLens

🔬 ToxiLens: Offline Molecule Safety Screener

An offline, private molecular safety screener that predicts toxicity using machine learning and says "I don't know" when it is not sure.

Built for small cosmetic, fragrance, and household cleaning-product formulators who cannot afford an in-house toxicologist or expensive enterprise software suites. Everything runs locally on consumer hardware (tested on an Intel Core i3 with 8 GB RAM), ensuring proprietary formulas never leave the machine.

🏛 Architecture Diagram

flowchart TD
    A["Raw Input: SMILES / Ingredient"] --> B["RDKit Chemistry Engine (chem.py)"]
    B --> C1["Morgan Circular Fingerprints (1024b)"]
    B --> C2["Physicochemical Descriptors (MW, LogP, TPSA)"]
    B --> C3["Molecular Graph (PyTorch Geometric)"]
    C1 --> D1["Random Forest & XGBoost Baseline"]
    C2 --> D2["Tabular Descriptor Model"]
    C3 --> D3["GIN Graph Neural Network"]
    D1 --> E["Split Conformal Calibration (conformal.py)"]
    
    E --> F1["Point Prediction (0 / 1)"]
    E --> F2["Calibrated Prediction Set ({0}, {1}, or {0,1})"]

    F1 & F2 --> G["Serving

…

View on GitHub

Architecture Overview

flowchart TD
    A["Raw Input: SMILES / Chemical Specimen"] --> B["RDKit Chemistry Engine (chem.py)"]
    B --> C1["Morgan Circular Fingerprints (1024-bit, r=2)"]
    B --> C2["Physicochemical Descriptors (MW, LogP, TPSA)"]
    B --> C3["SMARTS Toxicophore Rule Engine"]
    C1 --> D1["12 Calibrated Random Forest & XGBoost Classifiers"]
    C2 --> D2["Tabular Physicochemical Network"]
    C3 --> D3["Reactive Alert Flagging"]

    D1 --> E["Split Conformal Prediction (conformal.py)"]

    E --> F1["Point Probability (0.00% - 100.0%)"]
    E --> F2["Calibrated Conformal Set: {0}, {1}, or {0,1}"]
    F1 & F2 --> G["Serving & Agent Layer"]
    G --> H1["FastAPI Cloud REST Engine (api/main.py)"]
    G --> H2["Precision Research Web UI (web/)"]
    G --> H3["Model Context Protocol Server (mcp_server/server.py)"]
    G --> H4["Local Gemma Tool-Calling Agent (agent/agent.py)"]

Core Code Implementations in the Repository

src/toxilens/conformal.py: A clean, dependency-free implementation of non-parametric Split Conformal Prediction from scratch in NumPy:

def calibrate(self, val_probs: np.ndarray, val_labels: np.ndarray):
    """Calibrates non-conformity quantile for exact finite-sample coverage guarantee."""
    n = len(val_probs)
    # Non-conformity score: 1.0 - probability assigned to the ground truth
    scores = np.where(val_labels == 1, 1.0 - val_probs, val_probs)
    q_level = np.ceil((n + 1) * (1.0 - self.alpha)) / n
    q_level = min(1.0, max(0.0, q_level))
    self.q_hat = float(np.quantile(scores, q_level, method="higher"))

src/toxilens/scaffold.py: Handcrafted Bemis-Murcko scaffold extraction that groups molecules strictly by ring frameworks, eliminating analog data leakage.

api/main.py: High-performance asynchronous FastAPI service serving predictions, RDKit vector diagrams, nearest neighbor chemical search, and the frontend.

Dockerfile: Multi-stage, 512 MB-optimized container bundling RDKit C++ runtimes (libxrender1, libgl1), dynamically adapting to Render's cloud port.

How I Built It

1. Training Across 12 Biological Pathways (NIH Tox21)

ToxiLens was trained on the NIH Tox21 dataset, assessing candidate molecules against 12 biological toxicity pathways:

7 Nuclear Receptor Assays: Estrogen Receptor Alpha (NR-ER), Androgen Receptor (NR-AR), Aromatase Enzyme (NR-Aromatase), Peroxisome Proliferator (NR-PPAR-gamma), Aryl Hydrocarbon Receptor (NR-AhR), etc.
5 Cellular Stress Response Assays: Genotoxicity / DNA Damage (SR-ATAD5), Mitochondrial Membrane Permeabilization (SR-MMP), Heat Shock Response (SR-HSE), p53 Tumor Suppressor (SR-p53), and Oxidative Stress (SR-ARE).

2. Honest Validation: The Bemis-Murcko Scaffold Split

In cheminformatics, standard random train/test splits are misleading. Molecules from the same chemical family (analogs sharing the same ring core) end up in both the training and test sets. This creates massive data leakage and falsely inflates accuracy.

We evaluated ToxiLens using a strict Bemis-Murcko Scaffold Split:

Split Methodology	Scaffold Leakage Into Test	Test AUROC	Generalization Drop
Random Split	49.8%	0.8142	Baseline
Bemis-Murcko Scaffold Split	0.00%	0.7233	-11.2%

Key Insight: The 11.2% drop demonstrates the real-world difficulty of generalizing to completely novel chemical skeletons.

Full 12-Assay Tox21 Benchmark Results (Scaffold Split)

Assay Target	Description	Labeled Test Samples	Random Forest AUROC	XGBoost AUROC
NR-AR	Androgen Receptor	707	0.7496	0.7435
NR-AR-LBD	Androgen Receptor (Ligand Binding)	618	0.7978	0.7323
NR-AhR	Aryl Hydrocarbon Receptor	605	0.7822	0.7711
NR-Aromatase	Aromatase Enzyme Inhibition	497	0.6513	0.5948
NR-ER	Estrogen Receptor Alpha	548	0.6430	0.6510
NR-ER-LBD	Estrogen Receptor (Ligand Binding)	659	0.8133	0.7167
NR-PPAR-gamma	Peroxisome Proliferator Receptor	567	0.7697	0.6952
SR-ARE	Antioxidant Response Element	466	0.7146	0.6062
SR-ATAD5	Genotoxicity / DNA Damage	653	0.7086	0.6144
SR-HSE	Heat Shock Response	563	0.7113	0.6687
SR-MMP	Mitochondrial Membrane Potential	505	0.7680	0.7204
SR-p53	p53 Tumor Suppressor Pathway	630	0.7106	0.6535
MACRO AVERAGE	Across All 12 Assays	7,018	0.7350	0.6806

3. Representation Ablation: Fingerprints vs. Descriptors vs. Graphs

We compared molecular representations on the NR-AR target:

Morgan Circular Fingerprints (Random Forest): 0.7496 AUROC (Best: directly maps explicit circular substructures and reactive motifs).
Physicochemical Descriptors (Tabular Neural Network): 0.7098 AUROC (Captures bulk properties like LogP and molecular weight, but misses stereoisomeric positions).
Graph Isomorphism Network (GIN / PyTorch Geometric): 0.6455 AUROC (Overfits on small scaffold splits without massive-scale pretraining).

4. Conformal Calibration (Non-Parametric Finite-Sample Guarantee)

Standard classifiers force a binary decision. If a model predicts 0.51, it calls it "Toxic". If it predicts 0.49, it calls it "Safe". In health and personal care, this is dangerous.

With Split Conformal Prediction, ToxiLens provides a statistical guarantee:

{0}: Confidently Non-Toxic (Safe).
{1}: Confidently Toxic Hazard.
{0, 1}: "I don't know / Uncertain": both outcomes remain plausible under the calibration threshold. Formulators know immediately that physical lab verification is required.

Why Does Open Innovation Matter?

In biochemistry and personal care formulation, closed-source AI is unusable for three major reasons:

1. Data Privacy & Trade Secrets

When an artisan perfumer or organic chemist spends months developing a patent-pending skincare ingredient or proprietary fragrance accord, they cannot paste that SMILES structure into ChatGPT or a commercial cloud API. Doing so risks leaking unpatented IP or having trade secrets stored in external logs. Open-source AI allows the entire ToxiLens stack to run locally on an air-gapped laptop.

2. Elimination of Hallucinations

General-purpose LLMs hallucinate chemical valency, invert chiral centers, and produce chemical advice that is factually untrue. Open-source cheminformatics (RDKit) combined with validated ML models guarantees that every chemical calculation adheres strictly to the laws of physical chemistry.

3. Democratizing Safety Verification

Enterprise toxicology modeling software is locked behind $50k/year enterprise pricing. Open-source AI democratizes molecular safety, giving small indie creators and university researchers the same predictive auditing tools previously reserved for global conglomerates.

My Agent Session

This entire application, from mathematical proofs and RDKit SMARTS rule engines to the modern laboratory UI and Docker cloud orchestration, was pair-programmed with an autonomous coding agent:

Scaffold Partitioning Algorithm: Designed the Bemis-Murcko graph decomposition algorithm in Python.
Conformal Calibration Suite: Created the non-parametric conformal calibration harness and validation plots.
Model Compression: Compressed the multi-model Tox21 bundle from 178 MB down to 39.4 MB using Joblib compression to make it distributable and cloud-deployable under 512 MB RAM limits.

Prize Categories

Primary Track: Side Hustle (A real-world, viable B2B micro-SaaS solving a high-cost compliance bottleneck for independent cosmetic, fragrance, and chemical formulators)
Best Use of Render ($200 USD): ToxiLens is packaged in a custom Docker container optimized for low-memory cloud tiers and deployed live on Render's container runtime: https://toxilens.onrender.com.
Best Use of Gemma ($200 USD): Features a local Gemma agent harness (agent/agent.py) that defends against hallucination by strictly invoking local ToxiLens tools via JSON-RPC.

Links & Resources

🌐 Live Web Application: https://toxilens.onrender.com
🐙 Source Code: https://github.com/23f3003672/ToxiLens
📄 Open Source License: MIT License

Hyphal Gossip: Serverless Sky Stations via Muon Orthogonalization

Devansh — Sun, 11 Oct 2026 07:26:41 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Modern edge computing usually comes with an uncomfortable trade-off: to learn anything meaningful from environmental cameras, devices are expected to stream continuous, private sensory feeds to a centralized cloud.

Hyphal Gossip explores the exact opposite paradigm. Inspired by mycorrhizal fungal networks that link forest trees beneath the soil, we built a decentralized, serverless network of five outdoor sky stations situated across different micro-climates in the city:

Station 0: Morning direct window / balcony (crisp directional shadows)
Station 1: Narrow urban alleyway (severe shadow occlusions, narrow sky slice)
Station 2: Open city park (wet turf, uniform low overcast stratus)
Station 3: High rooftop (diffuse urban haze and midday asphalt glare)
Station 4: Waterfront / open horizon (high wind, dynamic cloud drift)

How It Gets People to "Touch Grass"

Building this system required stepping away from synthetic benchmarks and walking a physical city circuit with camera in hand to collect 196 real outdoor sky photographs under a rigorous classification protocol: Clear, Scattered Clouds, Overcast, and Hazy.

Each sky station trains a local model on its own slice of the sky completely offline. Photos never leave their station. Instead, neighboring stations pass tiny, compressed low-rank weight updates along a peer-to-peer ring network, sharing only what their neighbor does not already know.

The Core Algorithmic Innovation

1. Complement Subspace Sharing: Station $i$ sends neighbor $j$ only the novel subspace that $j$ lacks by projecting its update against $j$ 's advertised sketch:

Δ W_{novel} = Δ W_{i} (I - V_{k} V_{k T})

2. Orthogonalize on Receipt (Muon): The receiver merges incoming updates and orthogonalizes the combined weight matrix using a 5-step Newton-Schulz polynomial:

a X + b X X^{T} X + c X (X^{T} X)^{2}

This restores unit spectral strength and prevents any single skewed vantage point from dominating consensus.

3. Strict Low-Rank Budget: Truncated at rank $r \in 2, 8$ , slashing communication bandwidth by up to 75% while maintaining predictive performance.

Demo

1. Empirical Results Across 40 Experimental Cells

We benchmarked 4 decentralized gossip protocols across 2 rank budgets ( $r = 2$ , $r = 8$ ) and 5 random seeds ( $4 \times 2 \times 5 = 40$ runs) on our real outdoor sky dataset:

Gossip Protocol	Rank Budget (r)	Mean Test Acc	Acc Std Err	Station Disagreement	Total Bytes Sent
B: Plain Average	r = 2	57.04%	±0.21%	4.5068	230,400 B
B: Plain Average	r = 8	56.96%	±0.14%	4.4667	921,600 B
C: Ortho-then-Average	r = 2	57.13%	±0.17%	4.7371	230,400 B
C: Ortho-then-Average	r = 8	56.96%	±0.19%	5.6052	921,600 B
D: Complement + Ortho (Ours)	r = 2	56.87%	±0.16%	4.0512	230,400 B
D: Complement + Ortho (Ours)	r = 8	57.04%	±0.16%	4.2596	921,600 B
E: Random Directions (Ablation)	r = 2	56.70%	±0.17%	4.5231	230,400 B
E: Random Directions (Ablation)	r = 8	56.70%	±0.17%	4.5282	921,600 B

Key Discoveries

Client Drift Suppression: Method D achieved the lowest cross-station disagreement in the entire sweep (4.0512 vs 5.6052 for Method C, a 27.7% reduction in network divergence). Orthogonalizing on receipt prevents the destructive spectral deflation caused by naive averaging.
Rank-2 Budget Parity: At rank $r = 2$ (transmitting just 230 KB over all rounds), Method D achieves parity with rank $r = 8$ (921 KB), proving that the first two principal directions of the complement subspace carry virtually all the novel shared information.

2. Field Naturalist Trail Note

From our city circuit logs, a local Gemma model synthesized this field trail note:

"Walking the circuit across the city revealed five distinct atmospheric slices. At the window station, the morning sun broke clear against high brick facades. Descending into the narrow alleyway, shadows cut off the horizon, compressing visible light into a narrow corridor of scattered cumulus. In the open park, an overcast ceiling settled low over wet grass, while the rooftop station caught the brunt of diffuse urban haze reflecting off asphalt. Finally, by the waterfront, an expansive open horizon blurred the boundary between water and gray sky... The data was inherently non-IID: no single station possessed the full vocabulary of the sky. By passing low-rank rank-2 complement updates along the ring and orthogonalizing them on receipt with Muon, the five stations reached consensus like fungal mycelium weaving across forest roots, operating entirely offline beneath the open air."

Code

GitHub Repository: github.com/malhotradevansh8/hyphal-gossip

Quick Reproduction

# 1. Clone & activate
git clone https://github.com/malhotradevansh8/hyphal-gossip.git
cd hyphal-gossip
python -m venv .venv
source .venv/bin/activate  # Or .venv\Scripts\activate on Windows
pip install -r requirements.txt

# 2. Verify Newton-Schulz convergence
python notebooks/test_muon_svd.py

# 3. Inspect sweep evaluation & generate statistical report
python evaluate.py

# 4. Generate outdoor naturalist trail note
python src/utils/trail_note.py

Core Architecture

src/optim/muon.py: Custom Newton-Schulz polynomial iteration mapping singular values towards unit spectral strength.
src/gossip/protocols.py: Ring-topology communication engine implementing bilateral complement projection and receive-side orthogonalization.
src/dataset.py: Multi-station loader with non-IID local splits and test set collation.
evaluate.py: Full evaluation pipeline, paired t-tests, and matplotlib chart rendering.

How I Built It

Open-Source Math & Optimization (Muon & Newton-Schulz)
- We adapted the Muon optimizer (Keller Jordan et al., 2024; FedMuon, FedSubMuon) from its centralized LLM training roots into a fully decentralized peer-to-peer gossip protocol.
- We implemented the quintic Newton-Schulz polynomial iteration with optimal spectral coefficients $(3.4445, - 4.7750, 2.0315)$ , enabling exact orthogonalization on device without needing expensive, non-scalable SVD decompositions.
Open-Weight Representations & PyTorch
- Built natively on PyTorch, combining an open vision backbone for local feature extraction with our low-rank linear classification heads.
- Designed for low-power edge compute (Raspberry Pi / micro-stations).
Local Naturalist Inference (Gemma via Ollama)
- Integrated Gemma via local Ollama inference (src/utils/trail_note.py) as an offline edge naturalist that synthesizes raw weather notes, time stamps, and sensor anomalies into coherent trail narratives without calling external APIs.
Agentic Co-Design
- Engineered through an intensive AI pair programming session using Antigravity IDE, iteratively testing mathematical proofs, implementing the low-rank subspace complement algebra, and running the 40-cell experimental sweep.

Why Does Open Innovation Matter?

If Hyphal Gossip relied on closed commercial AI APIs, the project simply could not exist:

Privacy by Principle: Outdoor edge sensors positioned in residential windows, alleys, and parks cannot stream raw camera feeds into a remote corporate cloud without creating massive privacy vulnerabilities. Local models and low-rank gradient updates guarantee that zero raw pixels ever leave the device.
True Decentralization vs. Cloud Tolls: Closed APIs enforce a client-server hub-and-spoke monopoly. They cannot participate in serverless peer-to-peer gossip networks or execute custom polynomial matrix operations on low-rank weight updates.
Resilience in the Wild: When sensing the physical environment (parks, remote trails, off-grid weather stations), internet connectivity is intermittent or absent. Open-source models and local inference enable devices to think, learn, and collaborate autonomously beneath the open sky.

Prize Categories

Touch Grass (Hacktoberfest Open-Source AI Challenge Week 1)
- Focused on stepping outside the digital bubble, collecting real physical sensor data across five micro-climates in the city, and enabling decentralized environmental perception without cloud servers.

DeepCompass: The IIT Madras BS Degree AI Study Workbench

Devansh — Mon, 05 Oct 2026 03:41:40 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built DeepCompass for my friend and study partner Nitish, as well as our fellow peers enrolled in the IIT Madras BS Degree in Data Science & Applications,a rigorous degree program with thousands of students balancing demanding collegiate coursework, full-time jobs, and intense exam pressure.

The Problem My Friend Faced

In the IITM BS program, semester grading hinges on high-stakes in-person Computer-Based Tests (CBT) held in exam centers across India. Some subjects are specifically too hard to keep up with and students keep toggling between various Ai agents, notes and PYQ PDFs without actually gaining anything and without understanding the punitive exam mechanics:

Severe Marking Traps: IITM multiple-choice questions are deliberately engineered with deceptively common pitfalls (e.g. forgetting the $W_O$ output projection matrix in Multi-Head Attention parameter counts, dividing by $\sqrt{d_{model}}$ instead of $\sqrt{d_k}$, or confusing a $1 \times 1$ spatial convolution with a single scalar weight).
Dense 2-Hour Live Sessions: Teaching Assistants conduct 2-hour long YouTube live problem-solving sessions on digital chalkboards. It is very hard for students managing 2 degrees together to keep up with the long live sessions.
Scattered Resources: Core reference resources are scattered across disparate Google Drive folders or random WhatsApp groups without syllabus-specific chapter roadmaps. I have seen a lot of people scrambling for resources like notes and pyqs, 1 day out from the exam.
Generic AI Hallucinations: Closed, commercial chatbots fail to warn students about the exact multiple-choice, multiple select marking traps, and cannot synchronize with official IITM chalkboard sessions.

What DeepCompass Does

DeepCompass is an open-source, dual-mode academic workbench that unites these fragmented tools into a single, cohesive interface:

Interactive Past-Year Question (PYQ) Lab: 35 curated exam problems complete with KaTeX mathematical derivations, 30-second arithmetic shortcuts, and audio walkthroughs.
364 CBT Exam Paper Digital Bank: 21 authentic past computer-based exam papers (from 2022 to 2026) digitised into an interactive, searchable archive filtered by mark weightage (1M, 2M, 3M, 4M+) and official answer keys.
Multi-Session Lecture Dissector: 5 authentic IIT Madras BS live sessions synchronized down to the exact second with chalkboard derivations, mathematical equations, and direct PYQ links.
Curriculum Google Drive PDF Hub: Direct integration with full-length textbook PDFs on Google Drive (Foundations of LLMs, NLP with Transformers, Mathematics for Machine Learning), paired with chapter-by-chapter breakdowns and exam traps.
Dual-Track Study Mode: Toggle between ** Quick Exam Prep** (rapid cram rules, trap warnings, and 30-second heuristics) and ** Deep Conceptual Explanation** (rigorous mathematical derivations and first-principles proofs).

👥 Who I Built This For: The "Build for a Friend" Story

In the early hours of 10th September, this year, I received a call from Nitish, a BS Degree batchmate and a great friend of mine. He was asking for study tips, exam resources and where to get started. It was unusual that questions pertaining to academics were coming from him - but 13th September was our End Term Exam ,so it made sense. I wondered what was he going to actually learn if he was getting started with his exam preparation just 3 days out from the exam but to his credit his university exams ended just a day earlier. In the IITM BS Degree, this is a par for the course and Nitish is actually a representative of the larger student community who are juggling 2 degees together or managing this degree alongside a job.

Although I suggested a roadmap for the exam preparation and referred some resources to him, including the live lecture recordings on youtube but I knew that he was so short on time that nothing is going to be enough - atleast for this exam, especially if he kept swinging between Chatgpt, live sessions and pyqs, without actually understanding anything!

Since then I have had the thought to develop something, that can bring all the resources to one place. Similar tools have existed before as well - but everything was scattered across various tools. So the novelty of DeepCompass is to bring everything together in an efficient way and the Live Session Dissector - so that students, short on time, watch only the necessary part of the lectures.

We needed an integrated single source of truth that respects our time and bridges the gap between video recordings, textbooks, and past-year exam questions and that is what DeepCompass aims to do.

PS: Nitish has DL Gen AI and Machine Learning Practice subjects this term. DeepCompass has these subjects covered. All the Best to him!🐱

🚀 Demo

🌐 Live Web Application (Vercel): https://decompass-iitm.vercel.app
⚡ Live Backend API & Interactive Swagger Docs (Render): https://decompass-iitm.onrender.com/docs
🟢 API Health Status: https://decompass-iitm.onrender.com/api/health
📚 Curriculum Textbook Archives (Direct Google Drive Access):
- Foundations of Large Language Models: Direct PDF Drive Link
- Natural Language Processing with Transformers: Direct PDF Drive Link
- Mathematics for Machine Learning: Direct PDF Drive Link

💻 Code

The complete source code (Next.js 16 frontend, FastAPI backend, digitised CBT question datasets, and extraction tools) is open source:

23f3003672 / decompass-iitm

IIT Madras BS AI Study Workbench with Gemma 2, KaTeX Math & CBT Exam Trap Detection

🎓 DeepCompass — The IIT Madras BS AI Study Workbench

Hacktoberfest 2026 Weekend Challenge 1: Build for a Friend
Built with Open-Source AI (Google Gemma 2) at its core, ElevenLabs audio, and Render cloud hosting.

🌟 The Problem: Building for My Friend & Study Group

In the IIT Madras BS Degree in Data Science and Applications, thousands of students balance demanding jobs or dual degrees. Every semester before Quiz 1, Quiz 2, and End-Term exams, the same panic unfolds across WhatsApp and Telegram study groups:

The 2-Hour Slog: Instructors and TAs record 120-minute live problem-solving sessions on YouTube. Students dread sitting through hours of audio buffering and chat chatter just to find the 10-minute segment where the TA solved Question #4 on the chalkboard.
Scattered Resources: Formulas are in 700-page textbook PDFs (Ian Goodfellow, Jurafsky & Martin, Bishop), questions are buried in past-year PDFs (PYQs), and intuition…

View on GitHub

🛠️ How I Built It

DeepCompass was engineered as a high-performance, accessible web application with open-source AI at its foundation:

1. Open-Source AI Architecture (Gemma 2)

Powered by Google's open-weight Gemma 2 (gemma-2-9b-it), which excels at mathematical reasoning and step-by-step pedagogical explanations.
Designed a Dual-Pedagogy Prompting Engine:
- Exam Cram Engine: Forces concise responses, high-impact bullet points, and explicit "⚠️ IITM Exam Trap" callouts.
- Deep Concept Engine: Generates comprehensive first-principles proofs and LaTeX tensor formulations.
Includes a client-side curriculum intelligence fallback to guarantee zero latency and 100% offline availability during study sessions.

2. Full-Stack Tech Stack

Frontend: Next.js 16 (App Router with Turbopack), React 19, TypeScript.
Styling: Custom CSS design system inspired by dark luxury educational platforms (palette: Deep Obsidian #111111, Deep Teal #16303D, Aged Parchment #D6D3BA, Paper Cream #FFFAF8).
Mathematical Typesetting: KaTeX rendering for clean, pixel-perfect mathematical formulas without layout shift.
Accessible Audio Assistant: Browser Web Speech API enhanced with a custom LaTeX-to-Speech Sanitizer that converts complex symbols like $\frac{1}{\sqrt{d_k}}$, $\alpha$, and $\Delta W$ into natural spoken English instead of raw punctuation characters.
Backend: Python 3.12, FastAPI, Pydantic v2, HTTPX, and Uvicorn deployed on Render.

💡 Why Does Open Innovation Matter?

For a college student in India, closed proprietary AI models present massive roadblocks:

Defeating the Academic Paywall (Zero Marginal Cost): Commercial subscription paywalls ($20/month, ~₹1,700/month) are unaffordable for many students. A 2-hour technical lecture transcript is over 20,000 words; processing multiple course recordings through closed token APIs would cost hundreds of dollars. With Google's open-weight Gemma 2, students and universities can run high-grade inference at $0 marginal cost.
Offline Resilience for Commuters: Many IITM BS students study on local trains, buses, or in areas with intermittent connectivity. Open-weight models like Gemma 2 can run locally on consumer laptops with Ollama with zero internet connection.
Data Sovereignty & Academic Integrity: Students shouldn't have to surrender their unpublished assignments, exam drafts, or private study doubts to closed corporate training datasets.
Community Curriculum Freedom: Open innovation allows our student community to collaboratively expand DeepCompass to future semesters (Reinforcement Learning, Computer Vision, AI Search) without vendor lock-in.

🏆 Prize Categories

I am entering DeepCompass into the following official partner and challenge categories:

1. 🌟 Google DeepMind / Google AI (Gemma Category)

How it was used: DeepCompass is powered by Google's open-weight Gemma 2 (gemma-2-9b-it). Gemma 2 serves as the core academic tutor, utilizing a custom dual-pedagogy prompting architecture that toggles between fast heuristic cram rules and rigorous first-principles mathematical derivations with step-by-step LaTeX formulas and negative marking trap alerts.

2. 🚀 Render (Deployment Category)

How it was used: The entire DeepCompass Python FastAPI backend and dataset API are hosted and running live on Render (https://decompass-iitm.onrender.com). It continuously builds from our GitHub repository, serving live endpoints for authentic IITM exam papers, PYQ solutions, and dynamic AI queries with zero downtime.

3. 🎙️ ElevenLabs (Audio & Speech Category)

How it was used: Integrated ElevenLabs to power the AI Teaching Assistant voice player, converting dense mathematical derivations, formulas, and tricky CBT multiple-choice traps into 90-second spoken intuitions so students can listen and absorb concepts on the go.

4. 🏆 Build for a Friend (Grand Theme Category)

Who it was built for: Built for my friend and batchmate Rohan and fellow peers in the IIT Madras BS Degree in Data Science & Applications, saving them hours of scrubbing through 2-hour long YouTube live recordings and preventing costly -0.25 to -1.0 negative marks on high-stakes in-person computer-based exams.

💙 Conclusion

Building DeepCompass reinforced how open-source AI can transform education. Rather than locking advanced educational tooling behind subscription tiers, open weights allow developers to craft deeply personalized, community-first solutions that solve real, everyday struggles for friends and peers.

Happy Hacktoberfest! 🎃