DEV Community: Swayam Takkamore

SlothMind: Why Move Fast and Break Things When You Can Think Slow and Build Better?

Swayam Takkamore — Sun, 25 Oct 2026 21:35:05 +0000

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

What I Built

SlothMind is a private, local-first knowledge workspace designed around one central philosophy: sloths have life figured out - they conserve energy and avoid unnecessary movement.

As developers and researchers, we waste hours doing tedious knowledge work:

Hunting through fragmented folders for that one debugging fix we wrote months ago
Manually reading wall-of-text notes to extract checklists and action items
Summarizing meeting minutes, drafting PRDs, and rewriting specs
Polishing grammar, drafting emails, and restructuring documentation

SlothMind does all of that heavy lifting so you don't have to.

Key Capabilities

Local-First Markdown Vault: Notes live purely as standard .md files on your disk. No accounts, no cloud databases, and zero vendor lock-in.
Gemma 3 Inline AI Assistant (Ctrl+J): An inline assistant that recognizes intent automatically. It distinguishes casual conversation from explicit action commands (e.g. Summarize, Extract Action Items, Brainstorm, Fix Grammar, Make Shorter/Longer, Draft PRDs, Meeting Agendas), with interactive ▶ Continue generation and multi-turn follow-ups.
Steam-Style AI Model Library: Download, monitor, activate, and switch open-weight models with 1-click. Includes memory guards tailored for consumer GPUs (like an RTX 3050 4GB VRAM) and auto-restores the last used model on startup.
Source-Grounded Vault RAG with Honest Citations: Ask your vault questions across all your notes. SlothMind extracts relevant passages and cites the exact source notes with clickable jump links. If the information isn't in your notes, it honestly abstains rather than inventing hallucinations.
Calm, Distraction-Free Editor: Rich dynamic editing with / commands (/h1, /h2, /todo, /callout, /code, /table), atomic debounced autosave, centered/full-width modes, and keyboard navigation.

Demo

Here is SlothMind running 100% locally with Google's Gemma 3:

1. The Steam-Style Model Library

Manage, download, and hot-swap open-weight models with live GPU VRAM tracking.

2. Instant Slash Commands & Inline Sloth AI

Trigger actions or format blocks effortlessly with / commands and Ctrl+J.

Quick Start to Run Locally

git clone https://github.com/SwayamTakkamore/SlothMind.git
cd slothmind
npm install
npm run dev

Open http://localhost:5173, choose a vault folder, open the Model Library, and activate Gemma 3 1B Instruct!

Code

You can explore the source code on GitHub:

SwayamTakkamore / SlothMind

SlothMind

Your second brain. Your rules.
A local-first, privacy-focused Markdown knowledge workspace for developers and researchers.

What works in this build (Phases 0, 1, 2 & 3)

Vault management – Open an existing folder or create a new vault. Recent vaults are remembered in localStorage.
Safe filesystem access – All backend operations are scoped to the active vault. Path traversal, absolute paths, and symlink escapes are rejected. Writes use atomic rename (temp file + rename), renames/moves block silent overwrites, and deletes move items to a recoverable .trash/ folder.
File explorer – Nested folders and .md notes with expand/collapse, active-note highlighting, inline create/rename/delete actions.
Markdown editor – Source editing with a preview toggle, rendered with GitHub-flavored Markdown. UTF-8 content is preserved as-is.
Reliable autosave – Debounced autosave (800ms), save on blur/note switch, manual Ctrl+S/Cmd+S, and visible status (Saved, Saving..., Unsaved changes, Save error…

View on GitHub

Architecture Overview

Frontend: React 18, TypeScript, Tailwind CSS, TipTap/ProseMirror with Markdown serialization, and Lucide icons.
Backend: Node.js, Express, TypeScript, SQLite full-text search indexing, and a vault-scoped atomic filesystem engine.
AI Service: Python FastAPI service utilizing PyTorch and Hugging Face transformers with CUDA acceleration, streaming generation (TextIteratorStreamer), and hardware-aware quantization.

How I Built It

SlothMind is built from the ground up around Google's open-weight Gemma family:

Google Gemma 3 1B Instruct (google/gemma-3-1b-it): Our flagship model for consumer hardware. With its ultra-compact memory footprint, it runs entirely in ~1.86 GB of GPU VRAM on an entry-level NVIDIA RTX 3050 Laptop GPU, leaving plenty of headroom for fast token generation and instant streaming.
Google Gemma 3 270M Instruct (google/gemma-3-270m-it): Featherlight 500 MB model that runs on virtually any machine with near-zero latency.
Google Gemma 3 4B Instruct (google/gemma-3-4b-it) & Gemma 2 2B: For deeper reasoning and multi-step synthesis, offloading layers between GPU VRAM and system RAM.

Hardware-Aware Engineering

Smart Intent Classification: The frontend parser and backend prompt pipeline analyze prompt semantics to route requests to specialized template builders (draft, summarize, action-items, continue, explain, chat), ensuring small models produce well-structured Markdown.
Conversation & Confirmation Safeguards: Avoids unsolicited generation. If a user simply enters a greeting or casual question, the model responds conversationally and reconfirms before writing long drafts.
Session Auto-Restore: Both backend disk state and browser storage remember the last active model, auto-loading it into VRAM on startup so there's zero friction when you open your computer to write.

Why Does Open Innovation Matter?

Open-weight AI fundamentally changes what is possible for a personal knowledge base:

Absolute Privacy: Your notes often contain confidential code, company architecture, personal ideas, and unreleased plans. Sending every keystroke to third-party cloud APIs is a non-starter. Open models mean your second brain never leaves your machine.
Zero Operating Costs: No API tokens, no monthly subscriptions, and no surprise cloud bills. You download the model once and run it indefinitely.
Guaranteed Offline Autonomy: Whether you are on a plane, riding a train, or experiencing an outage, SlothMind functions completely offline without an internet connection.
Permanent Ownership: Proprietary APIs can deprecate endpoints, change pricing, or alter system prompts overnight. Open innovation guarantees that the model you build your workflow around remains yours forever.

My Agent Session

Built with agentic collaboration via Cursor(Claude Opus 5.5), Opencode Big Pickle, Gemini 3.8 Flash, T3 Code:

The Lazy Payoff

Here is how much effort SlothMind saved this week:

0 minutes spent searching: Instead of reading through 20 different meeting notes, a single question in Ask Your Vault synthesized the answer with clickable source citations in under 3 seconds.
Instant meeting-to-action checklists: Pasted raw transcripts, clicked Action Items, and got a clean, checkable Markdown to-do list ready to execute.
Automated drafting: Typed / or pressed Ctrl+J, selected a template (like PRD or Blog Post), and received an outline in seconds, followed by ▶ Continue to flesh out subsequent sections.

It turns hours of organizational chore work into single-click automations.

Prize Categories

Best Use of Gemma ($200)

SlothMind is built around Google's open-weight Gemma 3 models (gemma-3-1b-it, gemma-3-270m-it, and gemma-3-4b-it). We engineered a dedicated PyTorch/Transformers inference engine with CUDA optimization, streaming responses, and an in-app Steam-style library that makes running Gemma locally effortless on everyday laptops and workstations.

T3OS: The 100% Local, Air-Gapped AI Agent Operating System for Developers

Swayam Takkamore — Mon, 19 Oct 2026 06:53:41 +0000

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

What I Built

T3OS is a 100% local, air-gapped developer agent operating system and terminal UI built from the ground up for open-weight models. It turns any developer's workstation into an autonomous software engineering assistant—capable of inspecting workspaces, diagnosing bugs, writing code, and executing terminal commands—without sending a single token or line of proprietary code to a cloud server.

 ╭────────────────────────────────────────────────────────────────────────────────────────╮
 │ T3OS Agent                               Provider: [LOCAL] Model: google/gemma-3-4b-it │
 │ Session: 2026-10-18T21-00-36-995Z-tui-eed703                                           │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯

Who Would Pay For It?

Freelance Developers & Boutique Software Consultancies: Engineers working on client projects under strict Non-Disclosure Agreements (NDAs). Uploading client source code into multi-tenant cloud AI models (like OpenAI, Claude, or Cursor) often violates client security and IP clauses. T3OS provides full agentic autonomy with a verifiable 0-byte egress guarantee.
Fintech, Healthcare & Defense Contractors: Teams operating under strict SOC2, HIPAA, or air-gapped compliance requirements where external API calls are strictly firewalled.
Indie Hackers & Solo Builders: Developers building on tight budgets who cannot afford $20–$200/month per-seat agent subscriptions or volatile token bills, but still need high-velocity agentic pair programming.

The Problem It Solves

The Cloud API Tax: Commercial coding agents charge steep recurring monthly fees or bill per token. A single heavy refactoring loop can consume dollars in minutes. T3OS runs at $0 marginal cost forever on local hardware.
Data Sovereignty & IP Leakage: Cloud coding assistants send entire project files, dependency trees, and environment variables across the public internet. T3OS ensures your intellectual property never leaves your local silicon.
Offline Reliability: Coding on a flight, in a coffee shop with spotty Wi-Fi, or in a secure air-gapped facility is impossible with cloud-tethered agents. T3OS works seamlessly completely offline.

Demo

T3OS provides an interactive Ink-based Terminal User Interface (TUI), a fast one-shot CLI runner, and a lightweight local server.

1. Interactive Terminal UI (`t3os-tui`)

Watch T3OS autonomously analyze a codebase, request explicit permission before executing bash commands, and stream responses locally via Google Gemma 3:

# Launch the interactive terminal UI
node packages/tui/dist/bin.js

 ╭────────────────────────────────────────────────────────────────────────────────────────╮
 │ T3OS Agent                               Provider: [LOCAL] Model: google/gemma-3-4b-it │
 │ Session: 2026-10-18T21-00-36-995Z-tui-eed703                                           │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯

 ❯ inspect the failing test in packages/core and fix the bug
   ⚙ run_shell [audit test suite]

 ┌────────────────────────────────────────────────────────────────────────────────────────┐
 │ ⚠ Permission Required: run_shell (pnpm test packages/core/test/local.test.ts)         │
 │ [y] Allow once   [a] Always allow   [d] Allow session   [n] Deny                      │
 └────────────────────────────────────────────────────────────────────────────────────────┘

 > [y pressed]
   ✓ run_shell completed with exit code 0
   ⚙ read_file [packages/core/src/providers/local.ts]
   ⚙ write_file [packages/core/src/providers/local.ts]

   I diagnosed the issue: consecutive assistant turns were violating the Gemma chat 
   template requirements. I implemented `mergeConsecutiveTurns` to collapse multiple
   adjacent model messages into a clean alternating user/model dialogue. All 46 tests
   in packages/core are now passing!

2. Conversational Intent Gating

Casual chitchat ("hi", "how are you?") is answered immediately without polluting the context with tool schemas or firing unnecessary tool calls. Workspace commands ("fix this error", "list directory contents") automatically engage the full tool harness.

3. Quickstart

# Clone and build T3OS from GitHub
git clone https://github.com/SwayamTakkamore/T3OS.git
cd T3OS
pnpm install
pnpm build

# Run one-shot CLI command
node packages/cli/dist/bin.js run "summarize README.md"

# Launch the interactive TUI
node packages/tui/dist/bin.js

Code

The complete source code is available on GitHub under the permissive MIT license:

👉 https://github.com/SwayamTakkamore/T3OS

SwayamTakkamore / T3OS

T3OS

An open-source, native desktop agent harness for open-weight models. Gemma-first, backed by HuggingFace (hosted or local), with an Ink terminal UI and a Tauri desktop shell over one shared core engine.

Requirements

Node.js >= 20
pnpm >= 9
(optional) Rust + Tauri v2 toolchain for the desktop app
(optional) a secret-tool-compatible keyring for stored tokens

Install

pnpm install
pnpm build

Run

export HF_TOKEN=hf_...          # or: pnpm --filter @t3os/cli exec t3os auth set <token>
node packages/cli/dist/bin.js run "summarize README.md"
node packages/tui/dist/bin.js    # interactive terminal UI
node packages/server/dist/bin.js # HTTP + WebSocket server on :8787

Package binaries after pnpm build:

Binary	Package	Purpose
`t3os`	`@t3os/cli`	one-shot runs and config/auth
`t3os-tui`	`@t3os/tui`	interactive terminal UI
`t3os-serve`	`@t3os/server`	HTTP + WebSocket API

The desktop shell (@t3os/desktop) is a thin client of t3os-serve:

T3OS_API_URL=http://127.0.0.1:8787 pnpm --filter @t3os/desktop tauri dev

Test

pnpm test

License

MIT

View on GitHub

Monorepo Architecture

T3OS is engineered as a clean TypeScript monorepo managed with pnpm:

t3os/
├── packages/
│   ├── core/         # The ETCSLV agent runtime, streaming ONNX engine, & safety harness
│   ├── tui/          # Interactive Ink/React terminal UI with drag-and-drop chips
│   ├── cli/          # Zero-config CLI binary with Unix pipe support
│   ├── server/       # Local HTTP & WebSocket API bridge (:8787)
│   └── desktop/      # Cross-platform Tauri v2 desktop shell
└── package.json

Clean Test Suite: 36 test files with 378 unit tests passing across all packages (pnpm test).
Zero Third-Party Cloud Lock-In: Pure open-weight model focus with no telemetry or tracking scripts.

How I Built It

T3OS is built around modern open-source AI foundations, running quantized open weights directly on the host machine.

1. The Open-Source AI Stack

Model Family: Google Gemma 3 (google/gemma-3-4b-it, google/gemma-3-12b-it, google/gemma-3-27b-it) and Gemma 4.
Local Inference Engine: @huggingface/transformers (Transformers.js) with ONNX Runtime (INT4 / Q4 quantization). Models download directly from HuggingFace on first use and execute locally using CPU or WebGPU acceleration.
Real-Time Token Streaming Scanner (ToolCallScanner): Open-weight models without native function-calling APIs emit structured XML or markdown tags (<tool_call>...). T3OS implements an incremental streaming parser that detects tool invocations mid-stream, pausing generation to execute the tool safely.

2. The ETCSLV Formal Agent Harness

T3OS formalizes agent execution as a mathematical 6-tuple $\mathcal{H} = (E, T, C, S, L, V)$:

$E$ (Environment): Sandboxed local environment with strict path boundaries and process isolation.
$T$ (Tools): Normalized workspace primitives (read_file, write_file, run_shell) with smart alias resolution (bash, sh, cmd $\to$ run_shell).
$C$ (Context): Sliding context window manager featuring mergeConsecutiveTurns to guarantee strict alternating user/model message turns as required by the Gemma chat template.
$S$ (State): Trajectory recording, session state persistence, and step telemetry.
$L$ (Loop): ReAct execution loop with intent-gated tool provisioning (shouldProvideTools) to prevent hallucinated tool calls during conversational turns.
$V$ (Verification): Deterministic interactive safety engine ([y] Allow once, [a] Always allow, [d] Allow session, [n] Deny).

Why Does Open Innovation Matter?

Open innovation is not just a philosophical preference—for T3OS, it is what makes the product technically and economically viable.

True Privacy Without NDAs: Closed AI APIs require trusting a third-party corporation with sensitive enterprise IP, customer records, and proprietary algorithms. Open-weight models run inside your physical hardware boundaries, guaranteeing absolute data sovereignty.
Predictable Economics: Closed API pricing is subject to unexpected changes, sudden rate limits, and per-token fees. Open-weight models eliminate ongoing inference costs, allowing solo developers and small agencies to offer AI-powered software services with predictable margins.
Full System Control: With closed APIs, developers cannot alter the chat template, customize tokenization, or control low-level streaming behavior. Open innovation enabled us to adapt Gemma's chat template, implement custom XML token streaming scanners, and build an air-gapped permission system tailored exactly to developers' needs.

My Agent Session

This project was built collaboratively with AI coding agents like Cursor, Gemini 3.8 Flash and Opencode Big Pickle, running inside T3 Code. The iterative session involved designing the ETCSLV mathematical harness, implementing real-time streaming tool call parsers, solving terminal input blocking during permission prompts, and ensuring zero cloud dependencies.

My First User

Our first user was Kritika, a freelance penetration tester and smart-contract auditor. Kritika frequently works with pre-release, unannounced smart contracts and financial protocol codebases protected by heavy non-disclosure agreements.

"I was spending $40/month on cloud coding tools that I had to disable every time I worked on private client repos to avoid violating NDAs. With T3OS running Gemma 3 4B locally on my laptop, I audited an entire smart contract repository completely offline on a flight with zero internet access. The permission prompt gives me peace of mind that no command runs without my say-so."

Kritika feedback directly inspired our interactive [y]/[a]/[d]/[n] permission prompt and drag-and-drop file attachment chips.

Prize Categories

🌟 Best Use of Gemma ($200 Featured Category)

T3OS is built Gemma-first. We designed the core runtime specifically around Google Gemma 3 (google/gemma-3-4b-it) and Gemma 4:

Local ONNX INT4 Execution: Running Gemma models locally via @huggingface/transformers without external server dependencies.
Gemma Chat Template Compliance: Implemented mergeConsecutiveTurns to enforce Gemma's strict turn alternation requirements.
Custom Tool-Calling Prompt Engineering: Specially crafted system prompts and XML-based function calling schemes optimized for Gemma's reasoning capabilities.

Author: Swayam Takkamore (@swayamtakkamore)

Reality Checkpoint - The AI Game That Asks You to Put Your Phone Away

Swayam Takkamore — Mon, 12 Oct 2026 02:38:16 +0000

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

What I Built

Most modern apps and games treat human attention as oil to be drilled: infinite notification loops, engagement algorithms, red notification badges, and continuous screen gaze. Even outdoor and fitness games frequently double down on screen fixation, requiring players to stare into an augmented-reality viewfinder, check a real-time GPS map at street corners, or snap mandatory surveillance photos of every waypoint.

Reality Checkpoint flips the paradigm completely upside down:

The phone is the portal, not the destination.

Reality Checkpoint is an AI-powered, real-world adventure game that turns everyday physical surroundings into personalized quests. You spend 30 seconds choosing your available time window (5, 10, 15, or 30 minutes), select a sensory focus (optics/shadows, urban flora, soundscapes, micro-physics, or fleeting encounters), and receive a bespoke, grounded mission.

Then, the screen goes dormant.

The app enters an ambient, low-power dormant mode with a subtle breathing ring and a quiet countdown. There are no feeds, no popups, and no ads. You put the phone in your pocket, step outside, and experience physical reality with your own senses. When your time window is up, an organic audio chime sounds via the Web Audio API.

When you return, you describe what you noticed. A local open-weight AI model evaluates your reflection, rewards genuine sensory attention, poses Socratic follow-up questions, and files what you discovered into a persistent, evolving Field Journal using Reality Memory™.

[30s Setup] ──> [Bespoke Quest] ──> [Phone in Pocket / Screen Dormant] ──> [Return & Reflect] ──> [Reality Memory™ Compounds]

Who It Is For

Digital workers & developers suffering from screen fatigue who need a tangible, rewarding reason to step away from their desk for 10 minutes.
Urban explorers & flâneurs who want to rediscover familiar neighborhoods through fresh sensory lenses.
Mindfulness & curiosity seekers who prefer playful exploration over structured meditation timers or invasive fitness trackers.

Demo

Live Deployed App (Vercel): reality-checkpoint-mauve.vercel.app
GitHub Repository: github.com/SwayamTakkamore/Reality-Checkpoint

Running Locally with Google Gemma 4 (Step-by-Step)

Because true open-innovation outdoor gaming prioritizes personal privacy, zero cloud dependence, and zero metered API fees, the recommended way to experience the full AI engine with Google Gemma 4 (google/gemma-4-E2B-it) is running it locally on your computer:

# 1. Clone the repository
git clone https://github.com/SwayamTakkamore/Reality-Checkpoint.git
cd Reality-Checkpoint

# 2. Run the one-command launcher
./start.sh

What the launcher handles automatically:

Verifies your Python 3.11+ environment and backend requirements (fastapi, transformers, torch, accelerate).
Loads Google Gemma 4 (google/gemma-4-E2B-it) natively through Hugging Face Transformers.
Hardware Adaptation: Automatically checks for GPU acceleration (NVIDIA CUDA with float16/bfloat16) for rapid inference, and transparently falls back to CPU if a dedicated GPU is absent.
Serves the prebuilt nature-friendly UI unified with the API at http://localhost:8000.

Local Gameplay Walkthrough:

Open the Portal: Navigate to http://localhost:8000. The minimal nature aesthetic greets you in warm parchment (#fbfaf7), botanical pine and sage accents, and editorial Newsreader serif typography (with an instant dark mode toggle).
Select Parameters: Choose a 10-minute budget with the theme "The Architecture of Shadows".
Receive Quest: Gemma 4 generates "The Long Shadow", directing you to observe how sunlight and cast iron meet at a physical railing.
Dormant Mode: The screen dims into a minimalist breathing timer with ambient Web Audio chime indicators. Put the phone in your pocket and step outside.
Return & Socratic Reflection: You return and input your observation: > "I observed a jagged cast shadow from an iron balcony railing. The sunlight shifted by roughly two inches over ten minutes, softening along the penumbra as high clouds passed."
Evaluation & Reality Memory™: Gemma 4 evaluates observational depth on-device, awards XP, and records an episodic memory node (Category: Light, Tags: [visual, kinetic]) into your persistent local Field Journal.

Code

The entire codebase is open source under the MIT License:

SwayamTakkamore / Reality-Checkpoint

An AI-powered real-world adventure game running on Google Gemma 4 locally that turns ordinary surroundings into quests. Screen is dormant; reality is the game.

Reality Checkpoint

The screen is a portal, not a destination.

An AI-powered real-world adventure game. You tell it how much time you have and what you are in the mood for; it hands you a bespoke mission, you put the phone away and go live it, and when you come back you describe what happened. A local open-weight model reads your reflection, scores it, and files what you found into a growing narrative of your own neighbourhood.

Built for Hacktoberfest 2026 — Week 1: Touch Grass.

Every quest evaluation runs against a model on your own machine. No accounts, no API keys, no telemetry. If the model is unavailable the app degrades to a deterministic heuristic engine and keeps working.

The loop

Portal  →  30-second setup        time budget · theme · mood
        →  Bespoke mission        generated by a local model, safety-checked
        →  Dormant mode           countdown ring, chime when time

…

View on GitHub

Project Architecture

flowchart TD
    Client["Responsive PWA / Web UI<br/>(React 18 + Tailwind + Web Audio)"]
    API["FastAPI Backend Engine<br/>(Python 3.11+)"]
    LLM["Local Open-Weight LLM<br/>(Hugging Face Transformers: Google Gemma 4)"]
    GPU["GPU Acceleration (CUDA)<br/>Auto-Fallback to CPU"]
    DB[("Local SQLite3 Database<br/>(WAL Mode: reality_checkpoint.db)")]
    Memory["Reality Memory™ Engine<br/>(Episodic Knowledge Graph)"]

    Client -->|1. Request Quest (Time, Focus)| API
    API -->|Fetch Past Memories| Memory
    Memory -->|Contextual Memories| DB
    API -->|Prompt + Memories| LLM
    LLM --> GPU
    LLM -->|Structured JSON Quest| API
    API -->|Render Mission & Dormant Mode| Client

    Client -->|2. Submit Reflection| API
    API -->|Evaluate Depth & Attention| LLM
    LLM -->|Feedback, XP, Extracted Memory| API
    API -->|Persist Observation| Memory
    API -->|Update Progress & Narrative Tree| DB
    API -->|Return Socratic Follow-up| Client

Frontend (frontend/): React 18, Tailwind CSS, Lucide icons, synthesized Web Audio chime, and Screen WakeLock API. Features a minimalist nature-friendly light mode default with smooth dark mode.
Backend (backend/): FastAPI, Pydantic v2 schemas, SQLite3 persistence, and multi-layer safety guardrails.
Test Suite (backend/test_backend.py): 37 automated tests passing in Pytest verifying schema resilience, safety enforcement, and progression mechanics.

How I Built It

Reality Checkpoint is built natively around Google's Gemma 4 (google/gemma-4-E2B-it) running locally on-device through Hugging Face Transformers and PyTorch.

Instead of treating AI as an open-ended chatbot, the engine uses Gemma 4 for structured, deterministic game mechanics:

Hardware-Adaptive Inference (GPU-First with Seamless CPU Fallback):
The backend inspects available compute at startup. When CUDA is available, it leverages GPU acceleration (device_map="auto", bfloat16/float16). If running on machines without a dedicated GPU, or if GPU VRAM is constrained, the runtime automatically and transparently falls back to CPU execution with zero downtime or crashed requests.
Dynamic Quest Generation with Schema Enforcement:
Injects the player's past Reality Memories, time constraints, and narrative arc into a structured prompt, enforcing strict Pydantic JSON schemas.
Qualitative Reflection Evaluation & Socratic Probing:
Reads free-form text reflections, evaluates observational specificity, scores attention depth, extracts structured memory nodes, and poses an organic follow-up question.
Deterministic Heuristic Floor:
If the model is cold or offline, the backend automatically falls back to an intelligent rule-based engine. The player is never stranded outside because an AI process stalled.
Multi-Tier Safety Guardrails (backend/safety.py):
Hardcoded regex and semantic filters enforce that generated quests never advise trespassing, private property access, hazardous terrain, touching unknown plants or animals, approaching strangers, or using phones near active traffic.

Why Does Open Innovation Matter?

Absolute Privacy for Contemplative Reflections:
Personal observations about your neighborhood, daily walks, and quiet thoughts should never be ingested into proprietary training datasets or corporate cloud logs. Running Google Gemma 4 locally ensures your private reflections never leave your machine.
True Offline Resilience (Nature Doesn't Have 5G):
The entire point of "Touch Grass" is going outside. A hiking trail, state park, basement workshop, or remote shoreline often has zero cellular signal. Because the model, runtime, and SQLite database run locally on-device, Reality Checkpoint works completely offline.
Zero Financial Metering:
Habit-forming outdoor exploration shouldn't incur metered API bills or monthly paywalls. Open-weight models like Gemma 4 make contemplative technology accessible to anyone with standard personal hardware.

My Agent Session

The complete architecture, PRD, and test harness were orchestrated and validated using T3 Code and DevRelay agent workflows:

Harness & Agent: T3 Code with gemini-3.8-flash-high and opencode big-pickle
Session Focus: Ideation, PRD specification, local Hugging Face Transformers integration (google/gemma-4-E2B-it), nature-friendly minimalist UI redesign, test suite verification (37/37 pytest passed), and deployment configuration.
Workflow & Logs: Tracked across git commits and archived in the project documentation at SwayamTakkamore/Reality-Checkpoint.

Prize Categories

Primary Track: Hacktoberfest Open-Source AI Challenge: Week 1 ("Touch Grass")
Partner Categories:
- Best Use of Gemma: Integrates Google's Gemma 4 (google/gemma-4-E2B-it) locally via Hugging Face Transformers. Utilizes GPU-first execution with seamless CPU fallback, strict JSON schema parsing, and on-device private inference to generate real-world sensory quests and evaluate outdoor reflections.
- Best Use of Entire / DevRelay: Full agent orchestration, automated session documentation, and test-driven verification.

I Built My Friend Kritika a Project Mentor That Runs on Local Gemma

Swayam Takkamore — Mon, 05 Oct 2026 06:57:13 +0000

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

🪧 The Line Nobody Warns You About

You know the one. It shows up on basically every job post:

"Experience with real-world projects required."

I'm a student too, so I've seen it from the inside. You can ace every exam and still have nothing to point at. Tutorials end the second the video does. Real work is messier: there are tasks, blockers, deadlines, and (if you're lucky) someone you can ask when you're stuck.

That gap is what SkillPilot is about. And I built it for my friend Kritika.

The Short Version


Built for	My friend Kritika
The problem	Students have grades but nothing that looks like real project experience
What it is	An AI-powered learning platform that simulates real industry workflows
The open-source bit	Gemma, an open-weight model, running locally in my backend
Built with	Next.js 14 · Express + TypeScript · Flutter · MongoDB Atlas

So What Does It Actually Do?

If you're a student, it works like a tiny, friendly workplace:

Tell it what you're into and how comfortable you are. It hands you a real-feeling project: a title, a description, a difficulty level, a suggested tech stack, 5–8 concrete tasks and a deadline.
Work the board. Tasks live on a Kanban board (To Do, In Progress, Done), and your progress updates automatically as you move cards across.
Ask the mentor when you're stuck. It's an AI chat that knows which project you're in, so you get help with your thing, not a generic answer.
Finish and show it off. When the project's done, SkillPilot writes a portfolio entry, a skills summary and resume-ready bullet points. You get a public page at /portfolio/[username].

If you're a recruiter, you can browse and filter student profiles, open the projects and technologies behind them, and run an AI skill analysis that breaks a student's abilities down by category.

And every bit of AI in there runs on Gemma, locally in my backend. No closed API anywhere.

Poke Around the Repo

It's a monorepo. This is what the web/ side looks like when I ls around:

SkillPilot/web$ ls
backend  frontend

SkillPilot/web/frontend$ ls
next.config.js  next-env.d.ts  package.json  package-lock.json  postcss.config.js  src  tailwind.config.ts  tsconfig.json

SkillPilot/web/backend$ ls
node_modules  package.json  package-lock.json  src  tsconfig.json

There's also a mobile/ Flutter app and a docs/ folder (architecture, setup, API notes) at the repo root.

A quick honesty note: SkillPilot has a bit of a backstory. It began as a prototype for the TechmentorX Hackathon. What I'm writing about here is the current version, where the AI layer runs on open-weight Gemma locally in the backend.

How It's Put Together

 Next.js 16 (web)  ───┐
                      ├──►  Express + TypeScript API  ──►  AI service layer  ──►  Local Gemma
 Flutter (mobile)  ───┘              │
                                     └──►  MongoDB Atlas

The AI calls live in their own service layer in the backend, separate from the route controllers. Controllers just ask it for a project, a mentor reply, a portfolio or a skill score.

The stack

Layer	What I used	Why
Web	Next.js 14, TypeScript, Tailwind, Zustand, Framer Motion	Quick dashboards, a public portfolio route, simple state
API	Node.js, Express, TypeScript, Mongoose	Typed all the way through, fast to iterate on
Mobile	Flutter, Provider, Material 3	One codebase, and students live on their phones
Database	MongoDB Atlas	Projects, tasks, chats and portfolios are all document-shaped
Auth	JWT access + refresh tokens, bcrypt, httpOnly cookies	Boring, safe defaults
AI	Gemma (open-weight), run locally	Open weights I control, and no per-request cost

The API

Method	Endpoint	What it does
POST	`/api/auth/signup` · `/api/auth/login`	Accounts
POST	`/api/projects/generate`	AI-generated project
PATCH	`/api/tasks/:projectId/:taskId/status`	Move a Kanban card
POST	`/api/chat/:projectId`	Project-scoped mentor chat
POST	`/api/projects/:id/portfolio`	Portfolio and resume bullets
GET	`/api/recruiter/students`	Browse talent
POST	`/api/recruiter/students/:id/skill-score`	AI skill analysis

How Gemma pulls its weight

Project generation is a contract, not a chat. The Kanban board has to render whatever the AI sends back, so the output has to follow a shape (simplified):

{
  "title": "string",
  "description": "string",
  "difficulty": "beginner | intermediate | advanced",
  "techStack": ["string"],
  "tasks": [{ "title": "string", "description": "string" }],
  "deadline": "ISO date"
}

The mentor knows where you are. POST /api/chat/:projectId ties every conversation to one project, so answers are about what you're actually building.

Portfolios write themselves. When a project is finished, the AI looks at the project and its tasks and turns them into a summary, the skills you picked up, and resume bullets.

Skill scores are a starting point, not a verdict. Scoring a person is the most sensitive thing SkillPilot does. The score is there to help a recruiter dig into a student's real projects, not to replace looking at them.

Want to Run It?

# Backend
cd web/backend
cp .env.example .env     # add your credentials
npm install
npm run dev              # http://localhost:5000

# Frontend
cd web/frontend
cp .env.example .env.local
npm install
npm run dev              # http://localhost:3000

# Mobile
cd mobile
flutter pub get
flutter run

More detailed setup lives in docs/setup.md.

Why Open (and Local) Matters Here

The challenge asks where going open actually beats going closed. For SkillPilot, it's these five things.

1. The AI lives on my backend, not someone else's.
People think twice about sharing unfinished project ideas, "why doesn't my code work?" questions, and skill scores with their name on them. With Gemma, inference happens on hardware I control, so those prompts and answers don't get sent to a third-party model API. To be precise, the app's data is stored in MongoDB Atlas. Local Gemma keeps the model side in my hands, and I'd rather claim exactly that.

2. Students can't pay per token.
A mentor is only useful if you can ask the hundredth question without watching a meter. Local inference means no per-request cost and no model API key to rotate or leak. It doesn't get pricier when more students show up.

3. The model isn't wired into everything.
Since the AI calls sit in one service layer, upgrading or swapping the model stays contained to one place. I'm not at the mercy of one vendor's pricing, deprecations or surprise model updates.

4. Scoring people deserves something you can inspect.
A system that evaluates students for recruiters should sit on something you can examine and test. Open weights let me poke at how the scorer behaves instead of treating it as a black box.

5. The honest trade-off.
A local open model is smaller than the biggest hosted ones. I'm fine with that for a product aimed at students: cheaper, more private on the model side, and fully in my control.

	Closed API	Local Gemma (SkillPilot)
Prompts leave my backend	Yes	No
Cost per request	Per token	None
Swap or upgrade the model	Vendor decides	I decide
Needs a model API key	Yes	No
Raw capability ceiling	Higher	Lower

Where I'd Take It Next

Get SkillPilot in front of more students and fix whatever confuses them.
Show recruiters why a skill score came out the way it did.
Try other open models behind the same AI service layer.

Prize Categories

Best Use of Gemma: Gemma, an open-weight model run locally in my backend, powers every AI feature: project generation, the project-scoped mentor, portfolio writing and skill scoring.
Best Use of MongoDB Atlas: Atlas is the data layer behind an app built on an open-weight model. It stores users, projects, task state, chat history and portfolios.

Before You Go

Building for one person is a good constraint. Every feature has to earn its place by being useful to someone real, and for SkillPilot that someone is Kritika.

If you've mentored a junior, or you were the student with the empty portfolio, I'd love to hear what finally got you from "I've learned things" to "I've built something." Tell me in the comments. 👇

Did this project with my friend as a teammate - @aniket937

DEV Community: Swayam Takkamore

SlothMind: Why Move Fast and Break Things When You Can Think Slow and Build Better?

What I Built

Key Capabilities

Demo

1. The Steam-Style Model Library

2. Instant Slash Commands & Inline Sloth AI

Quick Start to Run Locally

Code

SwayamTakkamore / SlothMind

SlothMind

What works in this build (Phases 0, 1, 2 & 3)

Architecture Overview

How I Built It

Hardware-Aware Engineering

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

Best Use of Gemma ($200)

T3OS: The 100% Local, Air-Gapped AI Agent Operating System for Developers

What I Built

Who Would Pay For It?

The Problem It Solves

Demo

1. Interactive Terminal UI (t3os-tui)

2. Conversational Intent Gating

3. Quickstart

Code

SwayamTakkamore / T3OS

T3OS

Requirements

Install

Run

Test

License

Monorepo Architecture

How I Built It

1. The Open-Source AI Stack

2. The ETCSLV Formal Agent Harness

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

🌟 Best Use of Gemma ($200 Featured Category)

Reality Checkpoint - The AI Game That Asks You to Put Your Phone Away

What I Built

Who It Is For

Demo

Running Locally with Google Gemma 4 (Step-by-Step)

Local Gameplay Walkthrough:

Code

SwayamTakkamore / Reality-Checkpoint

An AI-powered real-world adventure game running on Google Gemma 4 locally that turns ordinary surroundings into quests. Screen is dormant; reality is the game.

Reality Checkpoint

The loop

Project Architecture

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

I Built My Friend Kritika a Project Mentor That Runs on Local Gemma

🪧 The Line Nobody Warns You About

The Short Version

So What Does It Actually Do?

Poke Around the Repo

How It's Put Together

The stack

The API

How Gemma pulls its weight

Want to Run It?

Why Open (and Local) Matters Here

Where I'd Take It Next

Prize Categories

Before You Go

1. Interactive Terminal UI (`t3os-tui`)