DEV Community: Rohith Pavithran

Tides: Tactile After-School Energy Pacing for My 11-Year-Old Daughter

Rohith Pavithran — Sun, 04 Oct 2026 16:45:58 +0000

What I Built

I built Tides for my 11-year-old daughter, Nia, who just started 6th grade.

Entering middle school is an immense sensory, physical, and cognitive leap. Every afternoon around 3:30 PM, Nia walks through the front door carrying an oversized backpack and an empty mental battery after 7 hours of changing classrooms, navigating social dynamics, noisy cafeterias, and intense physical education.

Whenever we tried traditional task managers or homework tracking apps, they made things worse:

High executive function barrier: Asking a drained 11-year-old to type task titles, configure due dates, and estimate minute durations creates immediate resistance and friction.
Guilt and anxiety spirals: When a 6th-grader falls behind, traditional apps flash red overdue badges and warning exclamation marks, creating avoidance and shame.
Homework bloat eating into sleep: Without strict boundaries, 20 minutes of math expands into the evening, pushing out her playtime, dinner, and bedtime.

Tides is an adaptive, offline-first personal energy-pacing Progressive Web App (PWA) designed to solve this in under 10 seconds:

10-Second Arrival Check-In: Nia opens the app on her phone or tablet, sees "How full is your tank, Nia?", and drags a single fluid, spring-physics slider. Releasing her finger triggers a satisfying haptic pulse and automatically logs her battery level. Zero "Submit" buttons, zero typing.
The 3-Zone Desk Dial: Her afternoon is visually mapped into three tactile zones:
- 🔵 Focus (Deep Blue): High cognitive work (homework, math). Hard-capped to prevent exhaustion.
- 🟢 Reset (Sage): Nervous system down-regulation (snack, walk, shower, quiet Lego time).
- 🟡 Joy (Amber): Non-negotiable play, drawing, games, and reading for fun.
Pluggable Adaptive Rule Engine: If Nia logs an arrival battery $\le 30\%$, Tides instantly triggers the Battery MVP Fail-Safe—shrinking focus to 20 minutes (only 1 Must-Do task allowed) and shifting 40 minutes into Reset. It also detects recurring fatigue patterns (e.g., Zombie Thursdays from double-PE and band) to proactively shield her schedule.
Frictionless Task Sorter & 15m Sprint Runner: Large tactile cards with single-tap stamps: 🔴 Must Do, 🟡 Next Up, and 🟢 Later. She taps "Start Sprint", focuses through a distraction-free 15-minute countdown, and finishes with confetti and 3 tactile reflection chips: 🟢 Breeze, 🟡 Fine, or 🔴 Drag.
Guilt-Free 21-Day Static Decay: Tasks parked in "Later" that sit untouched for 21 days are auto-sunsetted without alarming notifications.
Parent Dashboard for Rohith: Gives me visibility into Nia's weekly Vital 4 Metrics (Average Arrival Tank, Joy:Focus Ratio, Task Drag Rate, and Zombie Days) with rule calibration controls and an audit trail explaining why Tides adjusted her schedule.

Demo

Live Demo URL: https://tides-go8j.onrender.com/ (or run locally via npm run dev at http://localhost:5173/)
Architecture Blueprint & Specs: Included directly in the repository under docs/BLUEPRINT.md and docs/IMPLEMENTATION_NOTES.md.

Visual Walkthrough

1. Nia's Arrival Tank & The 10-Second Slider

When Nia arrives home, she adjusts the fluid slider with spring physics and tactile haptic feedback. If battery drops $\le 30\%$, the MVP Fail-Safe activates automatically:

2. The Tactile 3-Zone Desk Dial & Task Sorter

Afternoon time is distributed dynamically across Focus, Reset, and Joy. Nia can prioritize her work in under 15 seconds with single-tap 🔴/🟡/🟢 stamps:

3. Rohith's Parent Dashboard & Vital 4 Metrics

A bird's-eye view of chronic burnout risks, weekly joy-to-focus balance, and live rule audit trails:

Code

The complete source code is open-source and hosted on GitHub:
https://github.com/irmein/tides

Key Code Highlight: The Extensible Rule Pipeline

Tides avoids spaghetti if-else business logic by using a pluggable, priority-driven rule engine. Here is the contract and the Battery MVP Rule:

// src/engine/rules/base.rule.ts
export interface EvaluationContext {
  todayBattery: number; // 0 - 100%
  recentLogs: BatteryCheckIn[]; // Past 14-21 days of logs
  activeTasks: Task[];
  currentSchedule: DaySchedule;
  settings: UserSettings;
}

export interface RuleResult {
  ruleId: string;
  ruleName: string;
  triggered: boolean;
  priority: number; // 1-100 (100 = Critical safety override)
  actionType: 'OVERRIDE_TODAY' | 'MUTATE_WEEK' | 'DECOMPOSE_TASK' | 'AUTO_SUNSET';
  payload: Record<string, any>;
  reason: string;
}

export interface AdaptiveRule {
  id: string;
  name: string;
  priority: number;
  evaluate: (ctx: EvaluationContext) => RuleResult | null;
}

// src/engine/rules/batteryMvp.rule.ts
export const BatteryMvpRule: AdaptiveRule = {
  id: 'battery-mvp-fail-safe',
  name: 'Enforce MVP on Critical Battery',
  priority: 100, // Highest priority override
  evaluate: ({ todayBattery, settings }) => {
    const threshold = settings.batteryMvpThreshold || 30;
    if (todayBattery <= threshold) {
      return {
        ruleId: 'battery-mvp-fail-safe',
        ruleName: 'Enforce MVP on Critical Battery',
        triggered: true,
        priority: 100,
        actionType: 'OVERRIDE_TODAY',
        payload: {
          isMvpMode: true,
          maxFocusMinutes: 20,
          allowedPriorities: ['MUST_DO'],
          reallocateZone: 'RESET',
          autoShiftMinutes: 40,
        },
        reason: `Battery at ${todayBattery}% (<= ${threshold}%): Switched to MVP Mode. Only 1 urgent task allowed; Focus shrunk to 20m and 40m transferred to Reset.`,
      };
    }
    return null;
  },
};

How I Built It

Tides was built from the ground up prioritizing speed, instant offline access, and tactile kid ergonomics:

1. Technology Stack

Framework: React 19 + TypeScript + Vite for instant bundling and minimal footprint.
Offline-First Reactive Database: Dexie.js (IndexedDB). Every check-in, task status, and schedule adjustment is written synchronously to local device storage. The app works flawlessly on airplane mode or spotty home Wi-Fi.
PWA & Cache Strategy: vite-plugin-pwa + Workbox. The application shell, typography, and SVGs are precached via CacheFirst.
State Management: Zustand micro-stores (useEnergyStore, useScheduleStore, useTaskStore, useEngineStore) cleanly decoupled from UI rendering.
Tactile Physics & Motion: Framer Motion hydraulic spring configurations (stiffness: 300, damping: 24), Web Vibration API haptics, and pure HTML5 Web Audio API sound synthesis (zero external audio network requests).
Styling: Tailwind CSS with custom luminescent CSS variable tokens for the 3 zones.

2. AI Agent Pair Programming

The entire architecture, domain models, rule engine, and components were pair-programmed using the Google Antigravity IDE and autonomous agent harness:

Fast prototyping of tactile ergonomics (verifying thumb touch zones and 64px tap targets).
End-to-end browser subagent automated testing with video session capture.
Structured architectural blueprinting in markdown prior to writing production code.

Why Does Open Innovation Matter?

When designing technology for children—especially around mental health, daily energy, and school stress—open innovation is not optional; it is fundamental.

Child Privacy & Zero Commercial Telemetry (COPPA Compliance): Commercial children's educational apps frequently harvest analytics, device identifiers, and behavioral profiles. With Tides, all neuro-physiological data, daily mood tags, and schedule friction logs stay strictly inside Nia's device IndexedDB sandbox. There are no tracking scripts, ad SDKs, or cloud analytics.
Freedom from Gamified Dark Patterns: Many commercial study apps rely on streak pressure, red warning notifications, and monetization popups that trigger anxiety in young kids. An open-source, local-first app allows us to prioritize emotional safety: auto-sunsetting tasks without guilt badges and protecting playtime over homework bloat.
Extensibility for Diverse Neurotypes: Every child's brain regulates energy differently. Because Tides is built around a pluggable open rule engine, parents, teachers, and developers can contribute open heuristic modules:
- Rules for ADHD hyperfocus and executive function resets.
- Seasonal sports practice exhaustion mitigations.
- Exam season pace shields and sleep deficit protectors.

Open innovation made it possible to build a calm, respectful tool that serves a child's well-being rather than a tech company's engagement metrics.

My Agent Session

This project was architected, implemented, and verified with the help of an autonomous AI agent in the Antigravity IDE:

{% agent_session 4bc093b2-1a41-445c-9a11-efd2a777e451 %}

(Session transcript includes architectural blueprints, Dexie.js database schema migrations, rule engine unit evaluations, and automated browser walkthrough recordings).

Prize Categories

Primary Track: Build for a Friend / Loved One (Built specifically for my 11-year-old daughter, Nia, to protect her after-school energy and joy).
Special Categories:
- Best Offline-First / PWA Experience
- Best Open Innovation & Human-Centered Design

The Alpine Mirage: How Upgrading Python Broke My Build and Led to a Truer Security Posture

Rohith Pavithran — Thu, 30 Jul 2026 03:50:29 +0000

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry.

The Initial Goal: "Upgrade and Secure"

Like many developers, I recently fell into the trap of assuming that "smaller is always better, and newer is always safer." I decided to upgrade my terminal-based web UI project, py_terminal, to the bleeding-edge python:3.15-rc-alpine Docker base image.

The logic was sound:

Alpine Linux has a much smaller footprint, meaning a smaller attack surface.
Python 3.15 Release Candidate would give me early access to performance improvements and patches.

What followed was a cascading series of build failures that taught me a valuable lesson about container architecture, Python's C-API, and what actually makes a container secure.

The Descent into Dependency Hell

The moment I pushed the Dockerfile update and ran docker build, the pipeline exploded.

1. The Missing Wheels

The first error was abrupt:

ERROR: No matching distribution found for litellm==1.93.0

Because I was combining a release candidate of Python (3.15-rc) with Alpine (which uses musl libc instead of the standard glibc), pre-compiled binaries (wheels) simply didn't exist for several of my packages. pip was forced to download raw source code and build from scratch.

2. The Rust Compiler (Wait, Rust?)

One of litellm's underlying dependencies is fastuuid, which is written in Rust. Because pip was building from source, it attempted to download the Rust toolchain (cargo). It immediately failed:

Error loading shared library libgcc_s.so.1: No such file or directory

Because Alpine is so incredibly stripped down, it didn't even have the basic C runtime library (libgcc) required to run the Rust compiler.

3. Fighting the PyO3 API

Determined to win, I added the heavy build tools to Alpine (apk add build-base cargo libffi-dev). The build got further, but then crashed while compiling tiktoken and pydantic-core.

The bridge between Rust and Python is handled by a library called PyO3. It explicitly rejected Python 3.15 because it was too new! I bypassed this by injecting an environment variable: PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1.

I thought I had won, until the final boss appeared:

error[E0609]: no field `tp_new` on type `PyTypeObject`

Python 3.15 had made fundamental changes to its internal C-API, hiding fields like tp_new and tp_base. The Rust bindings in pydantic-core were incompatible at a structural level. It was physically impossible to build.

The Pivot: What Does "Secure" Actually Mean?

I took a step back. I realized that by trying to use Alpine to create a "secure, minimal" container, I was actually doing the exact opposite.

If I wanted to stay on Alpine, I was going to have to leave heavy compilers (GCC, Make, Rust) inside my container or build complex multi-stage pipelines. Compilers inside production images are a massive security risk.

I pivoted back to python:3.12-slim (a Debian-based image) and focused on actual security best practices rather than just chasing a smaller megabyte footprint.

The Fix

Here is the final Dockerfile we settled on:

FROM python:3.12-slim

# 1. Create a non-root user for security
RUN groupadd -r appuser && useradd -r -g appuser appuser

WORKDIR /app

COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY . ./

# 2. Change ownership of the app to the non-root user
RUN chown -R appuser:appuser /app

# 3. Switch to the non-root user before running the app
USER appuser

ENV PYTHONUNBUFFERED=1
ENTRYPOINT ["python", "terminal_web/main.py"]

Instead of fighting musl compilation, we leaned on Debian's pre-compiled wheels (keeping the image compiler-free). Then, we stripped the application of root privileges. If a vulnerability is ever exploited in my app, the attacker is trapped inside the restricted appuser, heavily minimizing the blast radius.

Going the Extra Mile: Trivy Automation

To ensure we didn't blindly introduce vulnerable packages again, we integrated Trivy scanning.

Not only did we add Trivy to our GitHub Actions CI pipeline to fail the build if CRITICAL or HIGH vulnerabilities are found, but we also built a custom AI Agent Skill to automate local reporting.

Now, with a single command, my local environment spins up a background Trivy scan, extracts the JSON data, and parses it into a beautiful Markdown and HTML table, ensuring that no vulnerable library sneaks in before I even push to the remote.

What I Learned

Alpine is a double-edged sword for Python: Unless you are prepared to build multi-stage Dockerfiles and compile C/Rust extensions manually, Debian-slim images are often much safer and significantly faster to build.
"Small" does not equal "Secure": Adding build-tools to an image negates the security benefits of its small size.
Identity is everything: Running your container as a non-root user is one of the single highest-impact security improvements you can make, regardless of your base image.

This Bug Smash journey was frustrating, but the end result is a highly stable, automatically-scanned, and truly secure container architecture.

Cleaning up Repository Bloat: Removing Redundant requirements.txt

Rohith Pavithran — Sat, 18 Jul 2026 13:53:16 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

The project rohithtp-cv is a personal repository dedicated to managing and rendering professional CV/resume configurations and pipelines. It streamlines dependency management to ensure clean, reproducible environments for building modern CV layouts.

Bug Fix or Performance Improvement

In this update, I targeted a common issue in repository maintenance: redundant configuration files. The repository contained a leftover requirements.txt file that was no longer actively utilized or synchronized with the core dependency management flow.

Leaving unused configuration files in a codebase increases technical debt, confuses automated dependency scanners (like Dependabot), and risks causing installation mismatches for future collaborators.

Code

You can view the full changes and the exact cleanup in the commit linked below:

Clean up redundant requirements.txt

My Improvements

The optimization involved a direct pruning of the project architecture:

Identified that the package dependencies were already properly specified elsewhere or no longer required this file.
Removed the redundant requirements.txt to streamline the repository structure.
Verified that local builds and automated pipelines function optimally without the file.

This simple architectural hygiene task reduces the clutter in the codebase, simplifies onboarding, and prevents potential security/version mismatches from unmaintained files.

Free Voice Music Curator: Ditch Premium Music Fees with ElevenLabs & Google AI

Rohith Pavithran — Sun, 12 Jul 2026 15:18:44 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

I built the Free Voice Music Curator, an intelligent full-stack audio player powered entirely by public APIs, legal Creative Commons music, and zero paid subscription walls.

Inspired by the challenge prompt of passion, I wanted to capture the absolute devotion fans and hobbyists pour into their musical worlds. However, classic web-streaming apps are trapped behind heavy OAuth logic or aggressive paid premium tiers. The Free Voice Music Curator solves this by allowing users to command a local audio player using natural voice strings (via ElevenLabs), which are dynamically parsed by Google AI to pull over 500,000 legal, free-streaming tracks from Jamendo.

🟢 The Free-Tier Architecture

[ ElevenLabs Agent ] ➔ Webhook ➔ [ Backend Server ] ➔ Jamendo REST API
                                        │
                                        ▼
                        [ HTML5 Audio Player Engine ] ➔ (Plays raw .mp3 stream)

Demo

The application is fully configured and ready!

Live Development Webhook: https://ais-dev-vtsuihfhfsyunprfhoszsh-559194232025.asia-east1.run.app/api/webhook/elevenlabs
Production Webhook Simulator: Included directly inside the UI console so you can fire direct preset configurations (e.g., 💤 Lofi Study, 🏎️ Synthwave, 🎸 Acoustic) to watch the system respond in real time.

Code

The interface features a gorgeous deep interstellar slate and emerald canvas (bg-slate-900 / text-emerald-400) alongside modern typography pairings (Space Grotesk and Inter).

Here is the clean Python Core Engine snippet used to process the incoming webhook metadata securely:

import random
import requests
import vlc  # Install via: pip install python-vlc

class FreeVoiceMusicCurator:
    def __init__(self, client_id):
        self.client_id = client_id
        self.base_url = "https://api.jamendo.com/v3.0/tracks/"

    def get_curated_stream_urls(self, target_genre=None, target_artist=None, limit=10):
        print(f"Querying free cloud library for: Genre={target_genre}, Artist={target_artist}...")

        params = {
            "client_id": self.client_id,
            "format": "json",
            "limit": 50,
            "audioformat": "mp32",
            "order": "popularity_total"
        }

        if target_genre:
            params["tags"] = target_genre.lower()
        if target_artist:
            params["artist_name"] = target_artist.lower()

        try:
            response = requests.get(self.base_url, params=params)
            data = response.json()
            tracks = data.get("results", [])

            stream_targets = []
            for track in tracks:
                stream_url = track.get("audio")
                if stream_url:
                    stream_targets.append({
                        "title": track.get("name"),
                        "artist": track.get("artist_name"),
                        "url": stream_url
                    })

            random.shuffle(stream_targets)
            return stream_targets[:limit]
        except Exception as e:
            print(f"API Fetch Error: {e}")
            return []

How I Built It

The execution pipeline flows fluidly across three modern technical frameworks:

Intelligent Conversational Agent (ElevenLabs): I built a blank agent powered by a custom webhook tool named play_free_genre_music. It listens for spoken triggers like "Play some high-energy synthwave beats" and extracts clean textual params (prompt, genre, artist).
Contextual AI Translation Engine (Google AI Studio): The backend leverages the gemini-3.5-flash model to analyze the full natural-language transcripts, scrubbing out specific moods, obscure tags, or strict artist names, complete with a local rule-based keyword fallback parser to guarantee zero downtime.
Responsive Web Player Platform: Built an HTML5 audio context interface complete with a live API resource monitor (tracking Jamendo's 35,000 free monthly request tier cap) and real-time scrolling telemetry log panels recording every single serverless event transcript.

Prize Categories

This application is being submitted to the following prize categories:

Best Use of ElevenLabs: For mapping custom voice conversational tools to a local audio state architecture seamlessly.
Best Use of Google AI: Using Gemini to turn messy, natural speech commands into highly structured metadata payloads.

Terminal Web 2.0: AI Preflight, Healing, and Safety

Rohith Pavithran — Sun, 07 Jun 2026 11:45:57 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

Terminal Web (py_terminal) is a powerful terminal-based UI web project utilizing Python and the Rich library for beautiful terminal output combined with advanced command execution capabilities.

As part of the Finish-Up-A-Thon, I transformed this tool by integrating an AI Safety Net—a proactive layer designed to protect users from executing destructive shell commands (e.g., rm -rf, git push --force) while maintaining a fluid and rapid developer experience. The safety net employs:

Tier-1 Heuristics: Instant, offline protection against common dangerous commands.
Tier-2 AI Preflight: LLM-powered risk analysis that summarizes potential consequences and affected resources for MUTATING+ risk levels.
Intelligent Self-Healing: A workflow that diagnoses failed commands (e.g., permission errors, missing paths) and suggests safe alternatives to get you back on track.

Demo

Project Repository: https://github.com/rohithtp/py_terminal

The Comeback Story

Previously, py_terminal was an effective CLI wrapper with dual execution modes (interactive and capture) and beautifully formatted outputs. However, it had one critical flaw: it blindly executed whatever bash command was provided, offering no protection against accidental system damage. In a modern development environment where LLMs are sometimes used to generate complex, unverified commands, ensuring those commands are safe to run locally became a high priority.

To "finish it up" for this hackathon, I drastically leveled up the tool's intelligence and safety by adding:

An AI Preflight Loop: Intercepts risky commands, uses LLMs to generate reversibility notes, and blocks execution until explicit user confirmation is given.
A Self-Healing Workflow: Catches non-zero exit codes, diagnoses the error (e.g., "No such file or directory"), and proposes an LLM-generated fix that gets re-routed through the safety preflight loop.
SQLite Caching: Caches preflight AI evaluations to avoid duplicate API calls and guarantees zero latency for repeated commands.
Offline Graceful Degradation: The UI falls back beautifully to local heuristic warnings when the LLM API is unavailable, ensuring the tool is always usable.
A Status Capture Utility: A built-in telemetry tool to rapidly verify repository and dependency health.

My Experience with GitHub Copilot

GitHub Copilot acted as an exceptionally fast pair programmer throughout this challenge. It was instrumental in scaffolding the pexpect-based automated test suite for validating the AI Safety Net, mocking out LLM network responses, and quickly laying out the boilerplate for the Rich UI panels.

When constructing the SQLite caching mechanism, Copilot seamlessly anticipated the database schema I needed and handled boilerplate queries, allowing me to focus entirely on the core business logic of the safety heuristics and healing loop. It transformed complex refactoring and UI layout tasks into smooth, effortless completions.

Team Members: @rohithtp

mnemo — A local-first learning agent that remembers, without leaking

Rohith Pavithran — Sun, 31 May 2026 09:20:10 +0000

This is a submission for the Hermes Agent Challenge: Build With Hermes Agent

What I Built

mnemo is a learning-management agent for kids and self-directed learners. It tracks topics, sequences them by prerequisites, schedules spaced-repetition reviews (SM-2), generates quizzes, and adapts the plan over time through a Hermes-driven feedback loop.

The problem: hosted AI tutors send a child's mistakes, struggles, and reading level to someone else's servers. Browser-only chat loops forget everything the moment the tab closes — no cross-session adaptation, no long-term plan. And LLMs happily hallucinate URLs and quiz answers, so nothing stops an unreviewed link from reaching a 6th-grader.

mnemo's answer is a three-part stance baked into the schema, not bolted on:

Local-first by default. SQLite (WAL) on-device, 7 tables, 3 migrations. Hermes-3 runs locally via Ollama. A HuggingFace API path exists for constrained hardware but requires explicit opt-in and is clearly labelled in the UI — every hosted call is logged to the events table.
Two gates before any content reaches the learner. Every external resource starts approved = 0 in the schema. A second gate joins a source_allowlist table at the SQL layer — even an approved resource is suppressed if its origin isn't a trusted source (khan-academy, ck12, internal-curriculum). Both gates have dedicated scenario tests.
The agent proposes; a human approves. Pace changes, resource-type shifts, and any preference write goes through a confirmation gate. The agent literally cannot mutate learner preferences without a human checkbox — enforced via an MCP deny-list, not just UI.

Demo

Pitch deck (single-file Reveal.js, no build step):
pitch.html — 6 slides covering the problem, the Hermes differentiator, architecture, the two-gate safety model, and a realistic dashboard mockup of the shipped UI.

Quick local run:

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
sqlite3 learning.db < migrations/001_init.sql
sqlite3 learning.db < migrations/002_quiz_bank.sql
sqlite3 learning.db < migrations/003_source_allowlist.sql
python -m uvicorn webapp.app:app --reload --port 8000

Open http://localhost:8000 for the dashboard, or run a Hermes session end-to-end:

ollama pull hermes3
curl -X POST http://localhost:8000/api/agent/session \
  -H "Content-Type: application/json" \
  -d '{"learner_id": 1, "backend": "ollama"}'

The dashboard streams each tool call the agent makes, then refreshes progress and the review queue automatically.

Code

Repository: gitea.com/rohithtp/mnemo

Key directories:

webapp/ — FastAPI REST + SSE + static dashboard (25+ endpoints)
mcp_server/ — stdio MCP server exposing 7 tools to Hermes
src/agent/ — Hermes session orchestrator, allowlist, memory, insights
src/learning/ — SM-2 algorithm, sequencing logic, safety/privacy gates
migrations/ — 3 SQL files, schema-version tracked
tests/ — 69 passing tests (SM-2 unit + integration + API + scenario)
docs/ — full build plan, decisions log, 25-risk register, two-profile docs

My Tech Stack

Layer	Choice
Database	SQLite (WAL mode) on-device · libSQL/Turso documented as forward path
Backend	FastAPI + uvicorn + SSE streaming
Agent runtime	Hermes-3 via Ollama (local) · HuggingFace Inference API fallback
Tool surface	stdio MCP (Hermes) + WebMCP progressive enhancement (Chrome 146+)
Frontend	Vanilla JS + plain CSS — no framework, no build step
Spaced repetition	SM-2 algorithm, implemented as pure functions
Tests	pytest — 15 SM-2 unit + 18 integration + 31 API + 5 scenario = 69 passing
Deployment	Dockerfile + systemd unit
Language	Python 3.11+ (3.14 tested)

All Python deps are pinned in requirements.txt. The Hermes-3 model digest is pinned by SHA256 and asserted at startup so a silent upstream change can't drift the agent's behaviour mid-session (R02 mitigation).

How I Used Hermes Agent

Hermes-3 is the orchestration brain for the whole adaptive loop. The reason it had to be Hermes specifically, not a stateless prompt loop, comes down to four capabilities:

1. Tool-calling over a real schema. src/agent/session.py runs a tool-calling loop where Hermes drives a study session by calling the 7 MCP tools (get_progress_summary, get_ready_topics, start_topic, get_next_review_items, record_review_result, recommend_resources, generate_quiz). Each call is logged to the events table with arguments and result. The agent isn't generating advice in prose — it's writing to SQLite through audited tools.

2. Cross-session memory. Every session writes a memory_note event summarising patterns the agent noticed. The next session's system prompt is injected with the most recent notes for that learner, so Hermes "remembers" that this kid struggles with unlike denominators across sessions, not just within one tab. Memory notes are per-learner and stay on-device.

3. Pattern analysis + human-approvable proposals. Phase 6 added POST /api/agent/insights/{learner_id}. Hermes reads the event trail across a configurable window, computes avg_quality, days_active, resource-type variety, and emits structured proposals like {"type": "pace", "direction": "increase", "reason": "avg quality above 4.0"}. Each proposal is stored with resolved_at = NULL and surfaces in the dashboard with Approve / Dismiss buttons. The agent never silently applies pace changes — a human resolves each proposal.

4. Allowlist-enforced tool boundary. src/agent/allowlist.py defines AGENT_ALLOWLIST and AGENT_DENY_LIST as constants. set_learner_preferences is on the deny-list, so even if the model is jailbroken into trying to mutate preferences directly, the session orchestrator raises PermissionError before the tool runs. This is the difference between "the UI hides it" and "the agent cannot do it."

The combination — local model + persistent memory + audited tool calls + human-in-the-loop on every state-mutating proposal — is what makes mnemo trustable as a coach for a child, not just for an adult tinkerer. That posture is what the Hermes agent makes practical; a hosted stateless chatbot can't enforce any of it.

StudyTrak // Astra Core – Gemma 4 Challenge Submission

Rohith Pavithran — Sat, 23 May 2026 17:42:27 +0000

StudyTrak // Astra Core – Gemma 4 Challenge Submission

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

StudyTrak (Astra Core) is an immersive, high-fidelity student spaced repetition planner and neural coaching console. Designed to work completely local-first or proxy securely via remote endpoints, StudyTrak solves the "academic attention fragmentation" problem. It merges class schedules, homework tracker boards, spaced-repetition card decks (SM-2 scheduler), and deep neural academic helpers into a single HUD-inspired dashboard.

Core Features

🗓️ Astra Chrono Scheduler: Interactive class blocks and room assignments synced with responsive real-time layout structures.
🎯 Spaced Repetition Flashcards: Localized FSRS/SM-2 simulator (with grades: Forgot, Hard Link, Good Match, Perfect Spot) scheduling item intervals adaptively.
🎙️ Multi-Modal Capture Panel: Scan worksheets (Camera/Photo uploads) or type natural language inputs to automatically parse schedule drafts and pending homework proposals.
💬 Subject Advisory Chat Tutor: Academic conversational helper grounded directly in defined high-school/college subjects.
🧘‍♀️ Empathetic Reflection Journal: Conversational weekly debriefs tracking achievements, struggles, and proposed behavioral corrections.
🔊 Voice Speech Synthesis: Listen to high-fidelity audio versions of daily briefings with an interactive audio player.

App In Google AI

AiStudio: https://ai.studio/apps/97a83485-4fc2-43ae-8eb7-b82d63cdb1e9

Code

The complete, pristine full-stack source code is published on Gitea at https://gitea.com/rohithtp/studytrak. You can clone, audit, or deploy the application directly from this repository.

How I Used Gemma 4

StudyTrak leverages the lightweight yet highly competent capabilities of the Gemma 4 model lineup to deliver a privacy-preserving co-pilot:

Model Choices and Fit:
- Gemma 4 Tiny (E2B - 1.5GB): Configured as the optimal on-device WebLLM/MediaPipe companion. We chose the E2B formulation because it easily fits within the standard modern browser sandbox, enabling sub-150ms real-time token generation for micro-scans and speech transcription parsing without any outbound network latency.
- Gemma 4 Standard (E4B - 3GB): Selected for core desktop semantic analysis, empathetic reflection summaries, and structuring homework proposals from handwritten worksheet snapshots. It balances rapid execution speeds with reasoning traits needed to provide high-quality structural mentorship.
Context Grounding:
Every prompt generated goes through a deep localized context packaging layer, supplying active subject indices, schedule constraints, and historic reflection streaks to completely ground prompt results with zero external leak risk.