DEV Community: Vinay Madival

Un-stuck: Autonomous AI agent swarms in your favorite social platforms

Vinay Madival — Sun, 18 Oct 2026 13:20:17 +0000

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

What I Built

Unstuck is a fleet of open-source AI support agents, one per messaging platform (WhatsApp, Telegram, Discord, and easy to extend), that walk ordinary people through app settings and problems one safe step at a time.

Everyone has lost ten minutes hunting for one setting, like setting a PIN on WhatsApp, locking a chat, or turning on 2FA on Discord. Unstuck meets people inside the app they're stuck in: it asks Android or iPhone, gives one step with the exact on-screen label, confirms each step, and cites the official help page.

Who would pay: small businesses and communities that run on these platforms and answer the same "how do I...?" questions all day, such as Discord server admins, Telegram community managers and WhatsApp-based shops. Each one could deploy a branded Unstuck agent instead of answering the same questions by hand. Digital-literacy programs and help desks for first-time smartphone users are another fit.

Safety is built in. Agents never ask for a PIN, OTP or password, they warn when someone is being scammed, and they refuse to help with accounts the user doesn't own.

Code

VINAYMADIVAL / un-stuck

Unstuck

Ten minutes back, for everyone. Unstuck is a fleet of open-source AI support agents, one per messaging platform (WhatsApp, Telegram, Discord, and easy to extend), that guide ordinary people through app settings and problems one safe step at a time for example "set a PIN on my WhatsApp". Built on Hermes Agent for the Hacktoberfest Hack Day Bengaluru 2026.

How it works

            Operator
               |
        +--------------+       reports only (health, drift, memory audit)
        | Central agent| ------------------------------------------+
        | SOUL.md      |                                            |
        +--------------+                                            |
     inherits BASE behavior (install.py)                            |
      |            |             |                                  |
 +----v---+  +-----v----+  +-----v----+                             |
 |WhatsApp|  | Telegram |  | Discord  |   independent Hermes        |
 | agent  |  |  agent   |  |  agent   |   profiles: own SOUL,       |
 | SKILL  |  |  SKILL   |  |  SKILL   |   SKILL, MEMORY, token <--+
 | MEMORY |  |  MEMORY  |  |  MEMORY  |
 +--------+  +----------+  +----------+

Central agent (central/SOUL.md): PART A…

View on GitHub

How I Built It

Agent harness: Hermes Agent (open source) runs each agent and its messaging gateway.
Model: [open-weight model you used, e.g. Gemma via Ollama, confirm before posting]
Central agent: its SOUL.md holds the base behavior, a repeatable "Unstuck loop" (clarify, locate, guide, confirm, recover, close, learn) plus the safety rules. Every sub-agent inherits it. The central agent also monitors fleet health, detects behavior drift and audits memory.
Platform sub-agents: each is an independent Hermes profile with its own SKILL.md task pack, its own private memory and its own bot token. Memory is never shared between agents.
My tooling (Python, standard library only):
- install.py builds each agent's SOUL as shared base plus platform persona, and never overwrites memory.
- fleet_health.py and memory_audit.py check health and drift, and scan memory for isolation problems and leaked PINs, phone numbers or tokens.
- new_agent.py scaffolds a new platform in seconds.
Quality: 18 evals covering task coverage and scam scenarios, 9 unit tests and GitHub Actions CI.
Learning: agents write anonymous lessons to their own memory, and a step that fails twice is tagged [STALE?] so the central agent can flag it for re-verification.

Why Does Open Innovation Matter?

Support agents handle people's most sensitive moments: security settings, scam attempts, locked accounts. Open source lets a business or community inspect exactly what the agent is told, run it on its own machine, and keep conversations off third-party servers. The safety rules and memory audit are plain files anyone can read and improve, instead of promises behind an API. An open-weight model also means the cost doesn't scale with every question, which matters for a side hustle selling to small communities. And because each agent is just a folder of Markdown, anyone can add a new platform without asking permission.

My First User

Two of my friends and me

Prize Categories

Best Use of Gemma

WatchTower : an open-weight agent for video incident investigation

Vinay Madival — Sat, 10 Oct 2026 04:54:43 +0000

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

What I Built

Somebody leaves a backpack on the grass outside the canteen. Hours later, security has to find out when, and who was near it. The usual answer is a person staring at a CCTV timeline, scrubbing back and forth until their eyes give up.

WatchTower is a local AI agent that does the screen part so people can do the outside part. You type the incident in plain English ("a blue backpack was left near the canteen around lunchtime"). WatchTower plans an investigation, searches the footage, follows the object over time, finds who was closest to it, pulls evidence frames and writes a report with a timeline. Then it drafts an alert for the right person and waits for a human to approve it. Staff spend their time walking to the actual spot, not sitting in front of a monitor.

It is for campus, facility and event security teams, and for anyone with long recordings who needs to find one moment.

Demo

https://watchtower-nzpb.onrender.com/

Code

VINAYMADIVAL / WatchTower

WatchTower: an open-weight agent for video incident investigation

Staff describe an incident in plain English ("a blue backpack was left near the canteen around lunchtime") WatchTower plans the investigation, calls tools on the recorded footage, recovers from failures writes an evidence report, and asks a human to approve before any alert is sent. Everything runs locally; no footage leaves the machine.

Built at Hacktoberfest Hack Day Bengaluru '26 (IEEE CIS, RIT).

What the AI does

Role	Model
Planner: chooses tools, rewrites weak queries, writes the summary	Gemma 4 (open-weight, via Ollama)
Visual verifier: confirms what a saved frame actually shows	Gemma 4 (multimodal)
Detection + tracking	YOLOv8n + ByteTrack (Ultralytics)
Text-to-image retrieval	CLIP ViT-B/32 + FAISS

Model terms: Gemma 4 Terms of Use · CLIP: MIT · YOLOv8: AGPL-3.0 · FAISS: MIT

See docs/ARCHITECTURE.md for the full system diagram.

Agent tools

list_objects · search_video · track_history · nearby_tracks…

View on GitHub

How I Built It

The whole thing runs locally on a laptop. No cloud API sees the footage.

Gemma 4 (gemma4:e4b, via Ollama) is the agent's brain. It reads the request, chooses tools, rewrites weak searches and writes the summary. It also acts as a visual verifier, looking at a candidate frame to confirm what is actually in it.
YOLOv8n + ByteTrack detect objects and give each one a persistent track ID across frames.
CLIP ViT-B/32 + FAISS turn detected objects into embeddings so plain-English queries can search the video.
FastAPI + Streamlit + SQLite hold the tools, the trace and the operations screen.

The agent has tools for searching the video, following an object's track, finding nearby people, grabbing evidence frames, verifying a frame, writing a report and drafting an alert. Tool arguments are validated, and errors go back to the agent as data. Failures don't crash the run: it retries, changes its query, and if it cannot finish it still produces a partial report. Ollama's native tool calling failed once on my machine, so I added a structured JSON fallback that works with the same tools.

One honest moment from testing: on a clip with no backpack, the agent searched three ways and then reported that it found no evidence of one, instead of making something up.

Why Does Open Innovation Matter?

Security footage is exactly the data you should not upload to a closed API. With open-weight Gemma 4, YOLO and CLIP, WatchTower runs fully on the user's own machine, so nobody has to trade privacy for capability. I could also inspect and fix the pieces: when native tool calling failed, I could build a fallback, which is not possible with a black-box endpoint. And because the stack is open, a campus or small business can run it without paying per query.

WatchTower never identifies people: it describes objects and clothing only, and results are treated as leads for a human to verify, not proof.

Prize Categories

Gemma (Featured): Gemma 4 is both the planner and the visual verifier.

AI Powered Travel Tracker App

Vinay Madival — Mon, 05 Oct 2026 04:19:56 +0000

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

What I Built

Travel Tracker is a small web app for logging the countries you've visited. You pick a user, search for a country by name (partial matches work, so typing "ind" finds India and Indonesia), and add it to that person's list. The visited countries are saved per user, so each person has their own travel journal.

I built it for my friend, who often travels different states and countries.

Demo

Live app: https://travel-tracker-app-1mty.onrender.com/
Demo Video: https://youtu.be/W4so6Wgsv9M (old; new will be updated).

Code

VINAYMADIVAL / Travel-Tracker-App

Travel Tracker App

A concise travel journal web app that lets users log and review countries they've visited with a quick search feature. It combines Express.js and PostgreSQL for dependable server-rendered pages and secure data storage.

🚀 Live Demo

Visit the app: https://travel-tracker-app-1mty.onrender.com/

📖 Table of Contents

Project Overview

Travel Tracker allows users to log and view visited countries. Built with Express.js, EJS, and PostgreSQL, it provides a server-side rendered interface with dynamic data querying.

Features

📝 Log visited countries per user
🌐 Search country names (partial match)
🖥️ Server-rendered UI with EJS templates
🚀 Hosted serverless on Render

Prerequisites

Node.js v14+
PostgreSQL (local) for development
Render CLI (optional)

Local Setup

Clone the repo

git clone https://github.com/<your-username>/travel-tracker.git
cd travel-tracker

Install dependencies:
```
npm install
```
Create a .env file based on .env.example…

View on GitHub

How I Built It

Backend: Node.js with Express.js handles routing and the app logic.
Frontend: EJS templates render the pages on the server, so the UI stays simple and fast.
Database: PostgreSQL stores three tables, countries, users and visited_countries. I seeded countries from a CSV of country codes and names using \copy.
Search: Country names are matched with partial text queries in SQL.
Deployment: The web service and the Postgres database both run on Render. The connection string lives in a DATABASE_URL environm

Open-source AI (in progress): I'm adding an AI layer using an open-weight model (Llama 3.2 / Qwen 2.5) served locally through Ollama. It will let users type trips in plain English ("I visited Japan and Italy last year"). The model extracts the country names, which are then matched against the PostgreSQL countries table. It will also suggest next destinations based on the user's visited list. I'm updating the GitHub repo with this soon.

Why Does Open Innovation Matter?

Everything in this project sits on open-source software: Node.js, Express, EJS and PostgreSQL. None of it needed a licence, a paid API key or anyone's permission, which let me go from an idea to a deployed app for a friend in a weekend. Because the stack is open, I could read the docs and source, fix my own mistakes, and host it anywhere. A closed, metered service would have made a small personal project like this harder to justify.

Open-weight models make the AI part possible without sending my friend's travel history to a third-party API. I can run the model on my own machine, so the data stays with me, and I don't pay per request. That's what makes adding AI to a small personal project realistic.

Prize Categories

Best Use of Gemma