DEV Community: Sapnil M

Verdant 🌿: The Anti-Screen Agent

Sapnil M — Sun, 11 Oct 2026 20:05:14 +0000

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

What I Built

The Digital Fatigue Crisis

As software developers and knowledge workers, we spend 10 to 14 hours every single day illuminated by the harsh blue glow of monitors. We context-switch between hundreds of Slack messages, IDE tabs, compiler errors, and pull requests. Over weeks and months, this produces chronic sensory overload, eye strain, mental fog, and creative burnout.

Almost every wellness, mindfulness, or "digital detox" app suffers from an absurd paradox:

To disconnect from your screen, they make you stare at your screen even longer.

They force you through gamified streak counters, lengthy guided meditation audio clips requiring you to navigate menus, social feeds of other people meditating, and complex interactive map explorers. You end up swapping one screen addiction for another.

Verdant's Core Philosophy: The 30-Second Rule

Verdant flips this paradigm entirely. Built specifically for the Touch Grass challenge, Verdant is an open-source AI micro-sanctuary discovery agent designed with a radical constraint:

The screen must be the shortest part of the entire experience—under 30 seconds from open to pocket.

Verdant doesn't want your attention. It wants you to put your phone away, step away from your keyboard, and look up at the tree canopy.

┌────────────────────────────────────────────────────────────────────────┐
│                        THE 30-SECOND FLOW                              │
└────────────────────────────────────────────────────────────────────────┘
  [ 0 to 3 Seconds ]   ──► Pick your nervous system state & available walk time
  [ 3 to 5 Seconds ]   ──► Mastra agent queries Tiger Data pgvector or live GPS
  [ 5 to 15 Seconds ]  ──► Receive 1 tailored pocket sanctuary & 4 tactile steps
  [ 15 to 30 Seconds ] ──► Tap "Start Walk & Disconnect" -> Screen Locks Out!
  [ 30s onwards ]      ──► Phone is in your pocket. You are outside touching grass.

Key Features

3-Second Nervous System State Input:
Instead of forcing users to search text or browse pins on a map, Verdant provides four targeted restorative states:
- 💻 Screen Glare (needs deep tree shade, canopy filtering, and eye relaxation)
- ☀️ Need Sunlight (needs open southern lawns, warm stone benches, and vitamin D)
- 🌀 Overthinking (needs moving water sounds, fountain babble, and white noise)
- 🤫 Quiet Solitude (needs secluded pocket groves with ambient noise < 45 dB)
Sub-Second Micro-Sanctuary Vector Retrieval:
Using Tiger Data PostgreSQL with pgvector and Mastra (@mastra/core), Verdant translates your mental state and available walk duration (5 to 30 minutes) into 768-dimensional embeddings and calculates cosine similarity (<=>) in under 20 milliseconds. It also supports Live GPS Discovery via OpenStreetMap to find real-world parks and green spaces within walking distance of your current coordinates anywhere in the world.
Tactile Screen-Free Sensory Mindfulness Missions:
Unlike visual navigation apps that keep you looking at turn-by-turn directions, Verdant's generateSensoryMissionTool creates a physical, non-visual ritual for the walk:
- Acoustic Focus: Count 3 distinct non-mechanical sounds (wind rustling through leaves, bird chirp, gravel crunch).
- Tactile Grounding: Touch cold limestone, moss, or textured tree bark for 15 seconds.
- Horizon Gazing: Look 50+ meters into the distance to reset strained ciliary eye muscles.
Disconnect Mode: Fullscreen Physical Lockout:
Once you tap "Start Walk & Disconnect", Verdant dims your screen to an ultra-low-brightness forest canopy palette, displays a countdown timer, and plays a soothing harmonic Tibetan Singing Bowl chime generated in real-time via the browser's Web Audio API (no external audio assets required). An explicit on-screen prompt instructs:

"Lock your device now. Slip it into your pocket. Your screen time is over."

Demo

📹 Video Walkthrough

🎥 Watch the Full Video Walkthrough on YouTube

(Experience the complete 30-second flow: mood selection, Tiger Data vector search, live GPS discovery, and fullscreen Disconnect Lockout Mode).

Local Setup & Live Experience

You can run Verdant locally in under 60 seconds:

# 1. Clone the repository
git clone https://github.com/SAPNIL-M/verdant.git
cd verdant

# 2. Install dependencies
npm install

# 3. Configure environment (optional - includes offline vector fallback)
cp .env.example .env.local

# 4. Start the development server
npm run dev

Visit http://localhost:3000 on your desktop or mobile browser.

Visual Walkthrough

1. Instant 3-Second Mood & GPS Input

Pick your sensory state, slide your walk time, and choose whether to discover live parks near your GPS coordinates or query Tiger Data's pocket sanctuaries:

2. Sub-Second Sanctuary Match

Verdant matches your mood against urban nature spots with walking time, neighborhood context, ambiance notes, and instant walking directions:

3. Screen-Free Tactile Sensory Protocol

A 4-step mindfulness mission that engages hearing, touch, and peripheral sight so you don't look at your device while walking:

4. Disconnect Mode: Fullscreen Lockout

Tapping "Start Walk & Disconnect" dims the screen, triggers a Tibetan singing bowl chime via Web Audio, and prompts you to pocket your phone:

Taking Verdant on a Real-World Walk

During development, I took Verdant outside for a real-world field test. At 3:15 PM, after 6 hours of continuous coding, I opened Verdant on a mobile browser, tapped "Screen Glare" and "15 minutes", and selected "Use Live GPS".

Within 4 seconds, the Mastra agent discovered a neighborhood pocket park with mature oak trees located 8 minutes away. I pressed "Start Walk & Disconnect", heard the soothing Tibetan singing bowl chime reverberate through my earbuds, locked the phone, put it in my pocket, and walked out the door. For the next 20 minutes, my screen stayed completely black. I touched moss-covered stone, listened to sparrows in the hedges, and returned to my desk with zero cognitive fatigue.

Code

Repository Link: https://github.com/SAPNIL-M/verdant

Architecture Diagram

flowchart TD
    User([User in Front of Screen]) -->|Selects Mood + Minutes <3s| UI[Next.js 16 App Router]

    subgraph Mastra Agent Pipeline ["Mastra Agent Framework (@mastra/core)"]
        Agent[verdantAgent]
        Agent -->|Checks Coordinates| GeoDecision{Live GPS vs Tiger Data?}

        GeoDecision -->|Live Coordinates| ToolOSM[fetchLiveNearbySanctuaries<br/>OpenStreetMap Photon API]
        GeoDecision -->|Mood & Distance| ToolTiger[searchSanctuariesTool<br/>Tiger Data pgvector]

        ToolTiger -->|Embedding <=> Cosine Distance| TigerDB[(Tiger Data Cloud<br/>Timescale PostgreSQL + pgvector)]

        ToolTiger --> SanctuaryData[Matched Micro-Sanctuary]
        ToolOSM --> SanctuaryData

        SanctuaryData --> ToolMission[generateSensoryMissionTool]
        ToolMission --> FinalPackage[Restorative Guidance + Mission]
    end

    UI -->|Invokes POST /api/agent| Agent
    FinalPackage -->|Renders Recommendation in <1s| UI

    UI -->|Click 'Start Walk & Disconnect'| DisconnectMode[Fullscreen Lockout Timer]
    DisconnectMode -->|Web Audio API Oscillator| Chime[Tibetan Singing Bowl Zen Chime]
    DisconnectMode -->|User Pockets Phone| Nature([Touching Grass Outdoors 🍃])

    subgraph Trace & Versioning ["Entire CLI"]
        Entire[entire.yaml & CLI Checkpoints] -->|Records session traces| GitRefs[refs/entire/checkpoints]
    end

Core Code Snippets

1. Mastra Agent Definition with Anti-Screen System Prompt

Located in src/mastra/agents/sanctuaryAgent.ts:

import { Agent } from '@mastra/core/agent';
import { searchSanctuariesTool } from '../tools/searchSanctuaries';
import { generateSensoryMissionTool } from '../tools/sensoryMission';

export const VERDANT_AGENT_INSTRUCTIONS = `You are Verdant, an outdoor disconnect companion and micro-sanctuary guide.
Your mission is to cure screen fatigue and cognitive overload for software engineers and knowledge workers by recommending nearby peaceful nature spots within a 5-15 minute walk.

CRITICAL RULES:
1. Prioritize screen-time minimization above all else. The user must be looking at the screen for under 30 seconds.
2. Discover the top micro-sanctuary from live GPS locations or Tiger Data pgvector based on the user's mood, walking limit, and quiet needs.
3. Use generateSensoryMissionTool to generate a tactile, screen-free sensory mindfulness mission for the destination.
4. Keep all explanations grounded, restorative, concise, and devoid of screen distractions.
5. Emphasize activating Disconnect Mode, pocketing the phone, and stepping outside immediately.`;

export const verdantAgent = new Agent({
  id: 'verdantAgent',
  name: 'verdantAgent',
  instructions: VERDANT_AGENT_INSTRUCTIONS,
  model: 'google/gemini-2.5-flash',
  tools: {
    searchSanctuariesTool,
    generateSensoryMissionTool,
  },
});

2. Tiger Data `pgvector` Spatial Vector Tool

Located in src/mastra/tools/searchSanctuaries.ts and src/db/client.ts:

// Sub-millisecond cosine vector distance query in Tiger Data
export async function querySanctuariesVector(
  embedding: number[],
  maxWalkMins: number = 15,
  limit: number = 3
): Promise<SanctuaryRecord[]> {
  const pool = getPool();
  const vectorStr = `[${embedding.join(',')}]`;

  const query = `
    SELECT 
      id, name, category, neighborhood, latitude, longitude,
      estimated_walk_mins, shade_rating, quiet_rating,
      ambiance_description, sensory_features, best_for_moods,
      (embedding <=> $1::vector) AS distance
    FROM micro_sanctuaries
    WHERE estimated_walk_mins <= $2
    ORDER BY (embedding <=> $1::vector) ASC
    LIMIT $3;
  `;

  const res = await pool.query(query, [vectorStr, maxWalkMins, limit]);
  return res.rows;
}

3. Real-Time Tibetan Singing Bowl Synthesizer (Web Audio API)

Located in src/lib/audio.ts:

// Synthesizes a calming singing bowl sound with natural inharmonic overtones
export function playSingingBowlChime(fundamentalFreq = 216): void {
  const ctx = new (window.AudioContext || (window as any).webkitAudioContext)();
  const now = ctx.currentTime;
  const duration = 4.5;

  // Natural singing bowl overtone ratios: Fundamental, Octave + minor 3rd, 2nd Octave
  const harmonics = [
    { freqMult: 1.0, gain: 0.45 },
    { freqMult: 2.76, gain: 0.22 },
    { freqMult: 5.4, gain: 0.08 },
  ];

  harmonics.forEach(({ freqMult, gain }) => {
    const osc = ctx.createOscillator();
    const gainNode = ctx.createGain();

    osc.type = 'sine';
    osc.frequency.setValueAtTime(fundamentalFreq * freqMult, now);

    // Exponential decay curve replicating metal resonance
    gainNode.gain.setValueAtTime(gain, now);
    gainNode.gain.exponentialRampToValueAtTime(0.0001, now + duration);

    osc.connect(gainNode);
    gainNode.connect(ctx.destination);
    osc.start(now);
    osc.stop(now + duration);
  });
}

How I Built It

Verdant brings together modern open-source AI frameworks, cutting-edge cloud vector databases, and developer tracing tools:

1. Mastra Framework (`@mastra/core`)

I chose Mastra as my agent runtime because of its first-class TypeScript DX, modular tool definition system, and lightweight execution model.

Tool Architecture: Rather than monolithic prompt stuffing, I built two purpose-specific Mastra tools (searchSanctuariesTool and generateSensoryMissionTool).
Prompt Guardrails: Mastra enforces that the agent never writes long essays or asks conversational questions that keep the user interacting with the chat window. The agent is explicitly conditioned to terminate the screen interaction immediately.

2. Tiger Data (Timescale Cloud PostgreSQL + `pgvector`)

Vector search shouldn't require a dedicated, expensive proprietary vector database. Tiger Data gives me robust PostgreSQL reliability with the raw speed of pgvector:

Vector Schema: I stored 768-dimensional embeddings generated with text-embedding-004.
IVFFlat Vector Indexing: CREATE INDEX sanctuary_embedding_idx ON micro_sanctuaries USING ivfflat (embedding vector_cosine_ops) WITH (lists = 10);
Hybrid Querying: Tiger Data allows me to combine semantic cosine distance (<=>) with hard relational SQL predicates (WHERE estimated_walk_mins <= $2 AND quiet_rating >= 4) in a single query execution plan.
Graceful Fallback: If DATABASE_URL is omitted in offline test environments, Verdant seamlessly falls back to a fast in-memory cosine engine so the user experience never crashes.

3. OpenStreetMap & Photon Geocoding

To ensure Verdant works for anyone, anywhere in the world, I incorporated live GPS geocoding via OpenStreetMap. When a user clicks "Use Live GPS", Verdant queries open geospatial endpoints to identify nearby municipal parks, arboretums, and green squares within walking distance, embedding and ranking them on the fly.

4. Entire CLI (`entire`)

I integrated the Entire CLI (entire.yaml) to track checkpoints, autonomous commits, and session execution traces during development. With Entire enabled on my repository, all agent transitions, tool calibrations, and code modifications are versioned with transparent trace logs.

Why Does Open Innovation Matter?

The Hacktoberfest Week 1 challenge prompt asks: Why does open innovation matter for what you built? What did it make possible that a closed API wouldn't?

For a wellness and anti-screen application like Verdant, open innovation is not just an architectural choice—it is a moral necessity:

1. Personal Privacy Over Surveillance Capitalism

Your mental health status ("I am experiencing severe anxiety and sensory overload") and your real-time physical GPS coordinates are among the most sensitive personal data points that exist. In proprietary wellness platforms, this data is routinely logged, ingested into user advertising profiles, and monetized to sell products. With open-source AI and transparent database infrastructure like PostgreSQL, user data remains strictly private.

2. Open Spatial Infrastructure vs. Monetized Maps

Closed commercial mapping platforms prioritize sponsored pins, commercial businesses, and high-density vehicle routes. They are disincentivized to show you an unmonetized public bench under a willow tree. By building on OpenStreetMap data and self-hosted vector databases, Verdant treats quiet public micro-sanctuaries as fundamental human rights, not ad space.

3. Transparent AI Behavior

Closed conversational AI assistants are programmed to maximize session duration and daily active engagement (DAU). Their underlying models will deliberately prompt you with follow-up questions to keep you chatting. By utilizing Mastra and open agent tooling, I was able to program my agent with the exact opposite objective: minimize screen time to <30 seconds and send the user away.

4. Zero-Cost Offline Resilience

Because Verdant is open-source and includes offline in-memory vector fallbacks, you can run it on a laptop in airplane mode in the middle of a national park with no cell reception. It costs nothing to operate, requires no recurring SaaS subscriptions, and will remain functional forever.

My Agent Session

I utilized the Entire Checkpoints CLI throughout the development and testing of Verdant. All checkpoints, session snapshots, and autonomous agent executions are tracked within the repository.

You can inspect the Entire configuration in entire.yaml and review status directly via:

# Check Entire tracking status
entire status

# View recorded development checkpoints
entire checkpoints

Verified Entire Session Status

Here is my live session verification showing Entire CLI actively recording on branch master:

The session traces capture the iteration from initial schema design in Tiger Data to Mastra tool integration, Web Audio synthesis, and live GPS fallback integration.

Prize Categories

I am officially submitting Verdant for the following featured partner tracks:

🏆 Best Use of Tiger Data

Implementation: Powered by Tiger Data Cloud (Timescale PostgreSQL) with the pgvector extension enabled.
Technical Highlights:
- vector(768) columns storing dense semantic representations of urban nature ambiance, acoustic tranquility, and sensory features.
- Sub-millisecond cosine distance sorting ((embedding <=> $1::vector) ASC) combined with walking duration relational filters.
- IVFFlat vector index with optimized list buckets (sanctuary_embedding_idx).
- Automated database seeder (npm run db:seed) and connection pooling configured in src/db/client.ts.

🏆 Best Use of Mastra

Implementation: Powered by Mastra (@mastra/core v1.75).
Technical Highlights:
- Custom verdantAgent with strict system prompt conditioning that actively rejects screen-time prolongation and enforces the 30-Second Rule.
- Multi-tool orchestration combining searchSanctuariesTool (spatial vector retrieval) and generateSensoryMissionTool (tactile mindfulness synthesis).
- Clean TypeScript schema validation using Zod for all inputs and outputs.
- Integrated directly into Next.js 16 App Router API routes (src/app/api/agent/route.ts).

🏆 Best Use of Entire

Implementation: Integrated with Entire Checkpoints CLI via entire.yaml.
Technical Highlights:
- Full development checkpoints tracked on branch master.
- Captures development trajectory, agent execution logs, and reproducible environment configurations.

🧪 Live Partner & CLI Test Proof (Parts 1, 2, and 3)

Below is the complete terminal verification executing npm run agent:test and verifying all three partner tracks:

Verification Part 1: Mastra Agent Registration & Tiger Data Connection

Verification Part 2: Tiger Data Vector Distance Searches & Stress Scenarios

Verification Part 3: Live GPS OpenStreetMap Discovery & Offline Fallback

Summary: Step Outside

The greatest gift technology can give us is not more time looking at pixels—it is the freedom to look away from them.

Verdant is live, open-source, and waiting to help you take your next walk. Open it up, pick your mood, step away from your computer, and go touch grass. 🌿

WhichModel? — I Built a AI Arena for My Friend to Prove Open Models Can Beat Commercial APIs

Sapnil M — Mon, 05 Oct 2026 06:58:14 +0000

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

What I Built

Every week, my friend Abhi asks me the exact same question:

"Bro, which AI model should I actually use? Do I need to pay \$20/month for closed commercial APIs, or can an open-weight model actually keep up with my real work?"

Whenever we look at public AI leaderboards (MMLU, HumanEval, or Chatbot Arena), the answers feel disconnected from real life. Abhi and my wider circle of friends aren't sitting around evaluating standardized high-school math competitions or abstract trivia. In reality, they are:

Debugging real code: Fixing subtle CSS flexbox/grid overflows and asynchronous Python backend errors.
Drafting high-stakes outreach: Writing cold emails to tech CEOs and startup hiring managers for internship opportunities.
Studying for exams: Condensing dense university biology lectures (like the biochemistry of photosynthesis or WW2 timelines) into crisp study guides.
Translating regional languages: Converting everyday colloquial phrases between English and regional languages like Malayalam without sounding robotic.

The biggest obstacle wasn't the models—it was brand bias. When an answer carries a famous proprietary logo, people automatically convince themselves it is smarter. When it’s labeled "open model", people scrutinize it twice as hard.

To solve this for Abhi and our peer group, I built WhichModel?: an interactive, double-blind AI benchmark arena powered by their own daily prompts.

flowchart LR
    A[Friend Submits Real Prompts] --> B[Async Inference Queue]
    B --> C[NVIDIA NIM: Llama 3.2 11B]
    B --> D[Groq: Qwen 3.8 27B]
    B --> E[Groq: GPT-OSS 20B]
    B --> F[Google: Gemini 3.5 Flash Lite]
    C & D & E & F --> G[Randomized Double-Blind Evaluation]
    G --> H[Friend Votes on Merit Alone]
    H --> I[Animated Model Reveal & Latency Stats]
    I --> J[Personal Scorecard & Community Leaderboard]

How It Works:

Submit Real Tasks: Friends enter 5–15 prompts categorized by task type (coding, writing, study_help, summarizing, translation, other).
Blind Comparison: Candidate open-weight models and a closed comparison baseline generate answers in the background. Prompts are rendered as anonymous cards (Answer A, Answer B, Answer C) with all identities, metadata, and token traces stripped.
The Reveal: Friends pick the best answer strictly on merit (or select "None are good"). Only after voting are the model identities, license types, response latencies, and token counts revealed.
Personalized Guidance: The /results/me dashboard gives each friend a custom verdict: "For coding, use Model X; for summaries, use Model Y", backed by empirical win-rate statistics.

Demo

🌐 Live Web Application: https://whichmodel.onrender.com/
📊 Live Community Leaderboard: https://whichmodel.onrender.com/results
🔍 Explore Public Prompts & Verified Answers: https://whichmodel.onrender.com/explore

The User Journey:

Invite-Gated Welcome: Visitors sign in using an access code (e.g., friends2026), choose a display name, and consent to AI processing terms.
Prompt Authoring: Form validation ensures prompts are between 5 and 15 items with category tags. A handy "Fill sample prompts" quick-button lets first-time testers jump in immediately.

Figure 1: Friends submit real-world prompts categorized across coding, writing, and study domains.

Double-Blind Card Arena: Side-by-side card layout with copy-to-clipboard buttons, syntax-highlighted code blocks, and zero brand leakage in network payloads.

The Model Reveal: Immediately after voting, the cards flip to expose the winning model, license, latency, and token metrics.

(Optional Screenshot 3: Model Reveal Card showing latency and token counts)

Instant Scorecards & Community Leaderboard: Pairwise win-rate calculation with sample-size warnings ($n < 10$) and the live open vs. closed showdown.

Code

The complete source code is public and open-source under the MIT license:

SAPNIL-M / WhichModel

WhichModel?

Ask your friends. Let the models compete. Find your best AI.

WhichModel? is a small, invite-only benchmark for answering a very practical question:

Which AI model works best for the things I actually do?

Instead of trusting generic leaderboards, people submit their own prompts, compare anonymous answers from several models, and vote for the answer they like best. The app then turns those votes into personal insights and a shared leaderboard.

It is built for friends, classmates, teammates, and anyone who wants a useful answer instead of another hype-filled model ranking.

The idea in one minute

Enter an invite code.
Add 5–15 prompts you really use for coding, writing, studying, summaries, translation, or anything else.
Wait while the models answer in the background.
Compare anonymous answers labelled A, B, C, and D.
Pick the best answer — or say None are good.
See which…

View on GitHub

GitHub Repository: SAPNIL-M/WhichModel
Tech Stack: Python 3.11+, FastAPI, Uvicorn, PostgreSQL (via SQLModel / SQLAlchemy), Jinja2, Vanilla JavaScript (0 heavy npm dependencies), and Bleach for XSS sanitization.
Test Suite: 18 automated tests passing in CI covering providers, async queues, double-blind security, and GDPR-style data deletion.

How I Built It

1. The Open-Source AI Matrix

WhichModel? is architected around accessible open-weight models, contrasted against a single commercial baseline:

Model	Kind	Host Provider	License Category	Role in Benchmark
Llama 3.2 11B Vision Instruct	OpenAI-compatible	NVIDIA NIM	Custom Open-Weights (Meta Community)	Open Candidate
Qwen 3.8 27B	OpenAI-compatible	Groq	Custom Open-Weights (Qwen Research)	Open Candidate
GPT-OSS 20B	OpenAI-compatible	Groq	Permissive Open-Source (Apache 2.0)	Open Candidate
Gemini 3.5 Flash Lite	Gemini REST API	Google	Proprietary Closed	Comparison Baseline

All models are defined declaratively in config/models.yaml. Swapping an endpoint or plugging in a local Ollama model takes four lines of YAML with zero code changes:

generation:
  temperature: 0.3
  max_tokens: 800
  system_prompt: "Answer helpfully and concisely."

models:
  - id: gpt-oss-20b
    display_name: GPT OSS 20B
    kind: openai_compatible
    base_url: https://api.groq.com/openai/v1
    api_key_env: GROQ_API_KEY
    provider_model_id: openai/gpt-oss-20b
    is_open: true
    license_type: permissive
    license_note: Apache 2.0
    live_enabled: true
    rpm: 6

💡 An Honest Note on Resource Constraints & Model Selection:

Let's be completely transparent: there are even larger, highly perfected open-source and open-weight models in the ecosystem today (such as 70B+ parameter checkpoints, specialized reasoning models, and massive community fine-tunes). However, as an independent developer without cloud grant funding, venture sponsorship, or high-end GPU clusters to inference those massive models, I utilized the best accessible models I could get my hands on via developer-tier and free inference APIs (NVIDIA NIM and Groq).

The fact that these lightweight, sub-30B models (like GPT-OSS 20B and Qwen 27B) still went toe-to-toe with a commercial closed model proves the point even more strongly: if lightweight open models can already win 53.3% of real-world matchups, benchmarking with larger, perfected frontier open models will yield even more commanding results in favor of open source.

(Small tidbit: If anyone, an inference platform, or a compute provider would like to offer access to more powerful models or infrastructure for hosting larger open frontier models, I am more than open to collaborating! Drop a comment or reach out—let's expand the arena!)

2. Double-Blind Data Integrity

To guarantee absolute double-blind evaluation, the backend enforces strict data sanitization:

The /api/next endpoint completely strips model_id, provider names, and latency metrics before sending answers to the browser.
Inspecting browser developer tools or DOM elements reveals only randomized UUIDs.
Model outputs are safely rendered through markdown and sanitized with bleach to prevent XSS injection from untrusted model generations.

# Server-side scrubbing: never leak model metadata before voting
@router.get("/api/next")
def get_next_prompt_for_picking(session_id: str, db: Session = Depends(get_db)):
    prompt, answers = select_next_unpicked_prompt(db, session_id)
    random.shuffle(answers) # Randomize card positions
    return {
        "prompt_id": prompt.id,
        "category": prompt.category,
        "prompt_text": prompt.text,
        "answers": [
            {"answer_id": a.id, "text_html": render_safe_markdown(a.text)}
            for a in answers
        ] # model_id, tokens, and latency are intentionally excluded!
    }

3. Fault-Tolerant Async Inference Queue

An in-process asyncio worker queries candidate models concurrently, enforcing per-provider rate limits (NIM: 3 concurrent requests, Groq: 2, Gemini: 2) with exponential backoff on HTTP 429.
Job states (queued, running, done, failed) are stored in PostgreSQL. If the cloud container restarts or wakes from sleep, pending jobs are immediately resumed without losing user input.

4. Pairwise Statistical Modeling

Each evaluation treats the user's chosen answer as winning head-to-head against every unchosen answer in that round.
Small sample indicators ($n < 10$) notify friends when data is preliminary.
Self-service "Delete my data" removes personal prompts and recalculates leaderboard aggregates in real time.

Why Does Open Innovation Matter?

Running this benchmark with real friend-submitted prompts produced surprising, empirical discoveries that debunked common assumptions about closed vs. open AI:

🏆 Empirical Benchmark Scoreboard (Live Results from `/results.json`):

Model	Open / Closed	License	Overall Win Rate	Coding ($n$)	Writing ($n$)	Study ($n$)	Summary ($n$)	Translation ($n$)	Median Latency
GPT-OSS 20B	Open	Apache 2.0	60.0%	75% ($4$)	50% ($4$)	33% ($3$)	60% ($5$)	75% ($4$)	1005 ms
Gemini 3.5 Flash Lite	Closed	Proprietary	66.7%	50% ($4$)	60% ($5$)	86% ($7$)	33% ($3$)	80% ($5$)	1992 ms
Qwen 3.8 27B	Open	Research	23.1%	0% ($2$)	0% ($3$)	0% ($2$)	75% ($4$)	0% ($2$)	766 ms
Llama 3.2 11B Vision	Open	Meta Comm.	27.3%	N/A	75% ($4$)	0% ($2$)	0% ($2$)	0% ($3$)	7448 ms

💡 Key Takeaway: Open-weight models won 8 out of 15 head-to-head showdowns (53.3% win rate) against the commercial closed baseline!

What This Taught Us About Open Innovation:

Open Models Beat Closed APIs on Developer Workloads: In coding tasks, GPT-OSS 20B won 75% of matchups, beating Gemini 3.5 Flash Lite. Abhi noticed that the open model gave direct, working code with minimal unnecessary fluff, whereas the closed model over-explained basic concepts.
Specialized Excellence Over Generic Monoliths: Qwen 3.8 27B was the undisputed speed champion (a blazing 766 ms median latency) and dominated summarization with a 75% win rate. For high-speed reading, friends preferred Qwen over larger closed models.
No Subscription Anxiety & Zero Vendor Lock-in: You can run these exact weights on your own machine using Ollama or vLLM. You aren't subject to unexpected pricing hikes, policy shifts, or API deprecations.
Honest License Awareness: We deliberately differentiated between true permissive open-source (Apache 2.0) and community open-weights (Llama Community, Qwen Research). Educating users about these distinctions ensures teams know their true commercial rights.

Prize Categories

🌟 Best Use of Render

WhichModel? was built, configured, and deployed natively on Render using an Infrastructure-as-Code Blueprint (render.yaml):

services:
  - type: web
    name: whichmodel
    runtime: python
    plan: free
    region: singapore
    numInstances: 1 # In-process worker requires single-node concurrency
    buildCommand: pip install -r requirements.txt
    startCommand: uvicorn app.main:app --host 0.0.0.0 --port $PORT --proxy-headers --forwarded-allow-ips='*'
    healthCheckPath: /health
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: whichmodel-db
          property: connectionString
      - key: SESSION_SECRET
        generateValue: true
      - key: DAILY_CALL_CAP
        value: "600"

databases:
  - name: whichmodel-db
    databaseName: whichmodel
    user: whichmodel
    plan: free
    region: singapore
    ipAllowList: [] # Private network isolation: accessible only by the web service

Why Render Was Essential to This Architecture:

Zero-Friction Infrastructure as Code: The entire environment—FastAPI app, environment secrets, and isolated PostgreSQL database—spins up reproducibly from a single declarative YAML file.
Handling Free-Tier Spin-Downs with Grace: Free cloud instances spin down after 15 minutes of idle time. WhichModel?'s worker architecture was engineered specifically for this: client-side polling keeps the instance awake while a friend is actively evaluating prompts, and if a cold-start does occur, the FastAPI startup hook immediately audits PostgreSQL and resumes any pending jobs without dropping a single submission.
Secure Isolated Database Network: The database uses ipAllowList: [], ensuring it is only reachable internally by our Render web service, preventing external database exposure.

🤖 Best Use of GitHub Copilot

GitHub Copilot (CLI & Agent) was an essential pair programmer throughout this rapid weekend sprint:

Foundational Scaffolding via Copilot CLI: Used GitHub Copilot CLI to accelerate Phase 1 architecture, generating boilerplate for the decoupled provider interfaces (app/providers/openai_compat.py and gemini.py) to normalize disparate vendor response schemas into a unified contract.
Comprehensive Test Suite Generation: Copilot helped write and parameterize the 18 automated tests in tests/, rapidly authoring mocked HTTP fixtures for provider retries (429 rate-limiting with exponential backoff), double-blind election fairness, and markdown sanitization.
GitHub Actions CI/CD Pipeline: Paired with GitHub Actions (.github/workflows/ci.yml) to automatically execute test suites on pull requests, ensuring continuous verification before code was merged and deployed live.

My Agent Session

This project was built pair-programming with Antigravity and GitHub Copilot CLI throughout the Hacktoberfest weekend:

Architectural Scaffolding: Implementing the decoupled provider abstraction (app/providers/base.py, openai_compat.py, gemini.py) and setting up comprehensive unit tests with mocked HTTP responses.
Frontend & UX Polish: Developing the responsive styling, card reveal animations, and safe markdown rendering pipeline.
Async Concurrency Tuning: Solving queue contention across disparate model rate limits and ensuring smooth recovery on cold boots.

All 18 tests pass cleanly, ensuring strict data privacy, election fairness, and resilience against external API hiccups.

What My Friend Said When They Used It

When I gave the link to Abhi to test on his own real coding and writing prompts:

"I was convinced Answer A on my Python script prompt was gemini because the syntax was concise and it didn't lecture me. When the card flipped and revealed it was GPT-OSS 20B running on open weights, I was shocked. I don't need to pay for closed API keys for my daily coding tasks anymore—I'm running this locally tonight."

Thank you to the DEV team, GitHub, and Render for hosting this Hacktoberfest Challenge! Check out WhichModel? and test your own prompts against open AI.

DEV Community: Sapnil M

Verdant 🌿: The Anti-Screen Agent

What I Built

The Digital Fatigue Crisis

Verdant's Core Philosophy: The 30-Second Rule

Key Features

Demo

📹 Video Walkthrough

Local Setup & Live Experience

Visual Walkthrough

1. Instant 3-Second Mood & GPS Input

2. Sub-Second Sanctuary Match

3. Screen-Free Tactile Sensory Protocol

4. Disconnect Mode: Fullscreen Lockout

Taking Verdant on a Real-World Walk

Code

Architecture Diagram

Core Code Snippets

1. Mastra Agent Definition with Anti-Screen System Prompt

2. Tiger Data pgvector Spatial Vector Tool

3. Real-Time Tibetan Singing Bowl Synthesizer (Web Audio API)

How I Built It

1. Mastra Framework (@mastra/core)

2. Tiger Data (Timescale Cloud PostgreSQL + pgvector)

3. OpenStreetMap & Photon Geocoding

4. Entire CLI (entire)

Why Does Open Innovation Matter?

1. Personal Privacy Over Surveillance Capitalism

2. Open Spatial Infrastructure vs. Monetized Maps

3. Transparent AI Behavior

4. Zero-Cost Offline Resilience

My Agent Session

Verified Entire Session Status

Prize Categories

🏆 Best Use of Tiger Data

🏆 Best Use of Mastra

🏆 Best Use of Entire

🧪 Live Partner & CLI Test Proof (Parts 1, 2, and 3)

Verification Part 1: Mastra Agent Registration & Tiger Data Connection

Verification Part 2: Tiger Data Vector Distance Searches & Stress Scenarios

Verification Part 3: Live GPS OpenStreetMap Discovery & Offline Fallback

Summary: Step Outside

WhichModel? — I Built a AI Arena for My Friend to Prove Open Models Can Beat Commercial APIs

What I Built

How It Works:

Demo

The User Journey:

Code

SAPNIL-M / WhichModel

WhichModel?

Ask your friends. Let the models compete. Find your best AI.

The idea in one minute

How I Built It

1. The Open-Source AI Matrix

2. Double-Blind Data Integrity

3. Fault-Tolerant Async Inference Queue

4. Pairwise Statistical Modeling

Why Does Open Innovation Matter?

🏆 Empirical Benchmark Scoreboard (Live Results from /results.json):

What This Taught Us About Open Innovation:

Prize Categories

🌟 Best Use of Render

Why Render Was Essential to This Architecture:

🤖 Best Use of GitHub Copilot

My Agent Session

What My Friend Said When They Used It

2. Tiger Data `pgvector` Spatial Vector Tool

1. Mastra Framework (`@mastra/core`)

2. Tiger Data (Timescale Cloud PostgreSQL + `pgvector`)

4. Entire CLI (`entire`)

🏆 Empirical Benchmark Scoreboard (Live Results from `/results.json`):