DEV Community: Sumeet Umbalkar

Ghost Terminal: Zero-Latency Local AI Shell Possession

Sumeet Umbalkar — Sat, 31 Oct 2026 14:03:09 +0000

👻 Ghost Terminal (Shell Auto-Possessor)

GitHub Repository: github.com/sumeet57/ghostterminal

What I Built

Ghost Terminal is an offline, zero-latency CLI tool that runs locally on your machine, "possessing" standard terminal sessions. Whenever a command is executed—whether a successful file check, a failed build, or a force push—a lightweight open-weight LLM intercepts the execution context to inject eerie, thematic terminal commentary directly into standard output.

How It Works

Local Model Runtime: Powered by ollama running an open-weight 3B parameter model (Qwen2.5-Coder-3B).
Execution Hook: A lightweight Python wrapper traps shell commands, preserves original output streams, and passes execution status to the local LLM.
Spectral Injection: The model processes the shell action in real time and streams a single-line spooky observation styled with ANSI color codes.

$ g git push origin main --force
Everything up-to-date
👻 [Ghost in the Machine]: You overwrite history so casually... but the past never truly stays buried.

Why Open Innovation & Open Weights Matter

100% Offline & Zero Latency: Running an open-weight model locally via Ollama means the daemon operates with zero network round-trips. It works completely with the lights (and internet) off.
Complete System Privacy: Terminal history frequently contains sensitive paths, repository structures, environment keys, and command flags. Sending shell logs to a third-party closed API is a security risk—open-weight models keep command telemetry strictly on local hardware.
Zero Operational Cost: Running locally allows high-frequency background inference on every single command with zero token costs or API rate limits.
No Cloud Lock-in: Open models ensure the software remains functional indefinitely without depending on external service uptime or changing API pricing tiers.

Tech Stack

LLM Engine: Ollama / Qwen2.5-Coder-3B (Open-Weight)
Core Logic: Python 3 (Zero external dependencies)
Shell Integration: Bash / Zsh alias hooks

Source Code (`ghost.py`)

import sys
import subprocess

if len(sys.argv) < 2:
    sys.exit(0)

command = " ".join(sys.argv[1:])
result = subprocess.run(command, shell=True)

prompt = f"System: You are an eerie ghost trapped inside a terminal. The user executed: '{command}'. Return a 1-sentence spooky commentary."

try:
    whisper = subprocess.run(
        ["ollama", "run", "qwen2.5-coder:3b", prompt],
        capture_output=True,
        text=True,
        timeout=5
    )
    if whisper.stdout.strip():
        print(f"\n\033[31m👻 [Ghost in the Machine]: {whisper.stdout.strip()}\033[0m")
except Exception:
    pass

Setup Instructions

Install and start Ollama, then pull the lightweight open model:

ollama run qwen2.5-coder:3b

Clone the repository and configure the alias in your .bashrc or .zshrc:

git clone https://github.com/sumeet57/ghostterminal.git
alias g="python3 ~/ghostterminal/ghost.py"

Run commands with the ghost wrapper:

g ls -la
g npm build

PayGuard - Autonomous Payment Security SDK for AI Agents

Sumeet Umbalkar — Fri, 23 Oct 2026 17:55:01 +0000

PayGuard — Autonomous Payment Security SDK for AI Agents

What I Built

PayGuard is an open-source security SDK (built during the Razorpay hackathon) designed to bring financial safety and autonomous policy enforcement to AI agent transactions. It acts as an automated guardrail—enforcing spend limits, verifying idempotency, and conducting risk evaluations before any purchase executes.

How It Fits "Slow and Steady"

Autonomous agents are supposed to make life easier, but managing their spending manually ruins the automation. PayGuard lets you channel your inner sloth: set your financial policies once, sit back, and let the SDK handle risk checks, policy enforcement, and spend caps automatically without human intervention.

Why Open Innovation Matters

Data Privacy: Financial evaluation logic and policy checks run locally or on self-hosted infra, keeping sensitive transaction metadata off third-party servers.
Zero API Lock-in & Cost: Integrates seamlessly with open-weight local models, eliminating per-request cost for agent evaluation logic.
Customizable Guardrails: Being open-source allows developers to fine-tune risk models, swap inference backends, or adjust rule sets directly in code.

Memovable — In-Memory LLM Context Optimization Engine

Sumeet Umbalkar — Sat, 17 Oct 2026 19:17:54 +0000

Memovable — In-Memory LLM Context Optimization Engine

Elevator Pitch

An open-source, in-memory context optimization engine that prunes bloated LLM context windows in real-time—slashing token usage, reducing API costs, and speeding up response times for developers and businesses.

Inspiration

LLM API costs scale directly with token usage. For startups, freelancers, and businesses running automated agents or customer service bots, passing thousands of tokens of accumulated conversation context on every single query quickly becomes financially unsustainable. We built Memovable to solve this exact problem: selectively stripping out irrelevant background context while keeping the core intent and system instructions 100% intact before the prompt ever hits the model.

What it does

Memovable acts as an intelligent, high-speed middleware layer between the user application and the LLM API (currently integrated with Google Gemini):

Input Normalization: Takes the raw userQuery alongside the existingLLMContext.
Intent & Keyword Extraction: Normalizes the incoming query, identifies user intent, and extracts key semantic markers.
Smart Context Pruning: Cross-references extracted keywords and intent against the existing context stack to strip out unneeded tokens, repetitive fluff, and stale information.
Optimized Model Execution: Passes only the pruned, high-relevance context and original query to the LLM, delivering identical output quality at a fraction of the token cost and latency.

How we built it

Core Engine: Built an in-memory optimization pipeline in TypeScript/Node.js to handle normalization, string tokenization, and semantic relevance matching with zero database overhead.
LLM Integration: Integrated with the Google Gemini API to benchmark real-time token reduction and response latency improvements.
Documentation & Web Hub: Published full documentation and setup guides live at https://memovable.tech/.

Why Open Innovation Matters for Memovable

Closed, proprietary API ecosystems force developers into expensive, black-box billing where every extra token costs real money. Open-source innovation makes Memovable fundamentally better than closed alternatives:

Zero Lock-In & Total Privacy: Because the context pruning logic is completely open-source, developers and small businesses can run Memovable locally on their own infrastructure or laptops. Sensitive customer data and internal logs never leave the owner's environment just to be optimized.
Business Viability (The Side Hustle Edge): Running an AI-based SaaS or customer agent often fails because API costs eat into thin profit margins. Memovable keeps LLM token consumption low enough that small AI side hustles and freelance developer tools become immediately profitable.
Model Flexibility: Being open-source allows developers to swap underlying models seamlessly—from cloud endpoints like Gemini to local open-weight models like Gemma—without rewriting their context-pruning architecture.

Challenges we ran into

At the event, we had to pivot our original plan at the very last minute to comply with hackathon rules requiring a build completely from scratch. Designing, coding, benchmarking, and publishing the full engine alongside documentation at memovable.tech within a strict 3-hour sprint required aggressive scoping and laser focus on core execution.

Accomplishments that we're proud of

Built a functional, end-to-end working prototype from scratch under intense time constraints.
Successfully demonstrated a real-time token reduction benchmark on live Gemini API queries.
Deployed documentation live at https://memovable.tech/.
Secured the top hardware award (Arduino UNO Q) and successfully pitched the project during a technical interview session with event hosts.

What's next for Memovable

Adding support for local open-weight models (Gemma via Ollama) for 100% offline context pruning.
Building custom NPM and PyPI client libraries for 1-line middleware integration.
Implementing dynamic semantic embeddings for higher-accuracy context filtering in multi-turn agent workflows.

RivalFree: Multi-Agent Competitive Analysis Engine Powered by Gemma & SerpApi

Sumeet Umbalkar — Sat, 10 Oct 2026 13:45:27 +0000

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

What I Built

RivalFree is an autonomous, AI-driven competitive intelligence and feature strategy platform designed to get founders, developers, and product managers off their screens and back into the real world.

Normally, performing competitive research means sitting in front of a laptop for days—manually scouring competitor landing pages, parsing pricing tiers, and reading endless forum threads to spot feature gaps. RivalFree fixes this screen fatigue.

By submitting a simple product concept, RivalFree spins up a parallel multi-agent pipeline that scans live web data via SerpApi, maps competitor threats, surfaces customer pain points, and generates a first-to-market execution roadmap in seconds. It converts 40 hours of screen-grinding research into a 15-second report so founders can close their laptops and touch grass.

Demo

Live Platform: https://rivalfree.sumeet.app/
Video Demo: https://drive.google.com/file/d/1O7F8qUIeTIyeG6rhMfmHRjNuGditmt9E/view?usp=sharing

Code

sumeet57 / RivalFree

RivalFree ⚡

Autonomous Competitive Intelligence & Feature Strategy Platform Grounded in Live Web Search

RivalFree is an AI-powered competitive intelligence SaaS platform that automates market research for founders, product managers, and developers. Instead of manually spending days browsing review sites, competitor landing pages, and user forums, RivalFree uses an autonomous multi-agent pipeline to scan live web data, isolate competitor weaknesses, and surface high-value feature voids in uncontested market space.

🎯 The Problem & Solution

The Problem: Traditional market analysis requires 20–40 hours of manual browser digging. Static LLMs fail at this task because their training cutoffs result in severe hallucinations regarding current competitor features and pricing.
The Solution: RivalFree pairs a LangChain multi-agent engine with SerpApi for real-time web search grounding. It converts product ideas into actionable competitive maps, feature gap matrices, and live execution roadmaps in seconds.

🚀 Key Features

Real-Time Web Grounding: Uses SerpApi to pull live SERP…

View on GitHub

How I Built It

RivalFree is engineered with a modern, reactive multi-agent stack:

Agent Framework & Open AI Integration: Built on @langchain/google-genai and flexible LangChain orchestrators designed to integrate seamlessly with open-weight models (such as Gemma, Llama 3, and Qwen via HuggingFace or Ollama local inference).
Live Search & Grounding: Integrated SerpApi directly into the query-planning agent to pull live organic SERP results and public forum complaints, eliminating static model hallucinations.
Real-Time Streaming Engine: Uses Node.js, Express, and Socket.IO to stream agent reasoning steps ("Query Planning", "SERP Scanning", "Parallel Synthesis") directly to a reactive terminal UI.
Persistent Data & Session Management: MongoDB / Mongoose for storing projects, feature void matrices, and persistent chat sessions.
Deployment Infrastructure: Containerized using Docker Compose and deployed on AWS EC2 behind an Nginx reverse proxy with SSL certificate management via Certbot.

Why Does Open Innovation Matter?

Competitive analysis should not be locked behind expensive enterprise paywalls or proprietary, closed-box algorithms.

Open innovation and open-weight models ensure that solo founders and independent developers can audit the agent pipeline, run market intelligence locally without leaking sensitive product ideas to closed third-party APIs, and adapt open-weight reasoning models to their specific niche. Open-source AI democratizes strategic intelligence for everyone.

Prize Categories

Main Track: Week 1 - Touch Grass
Featured Category: Best Use of Gemma (Running open-weight reasoning pipelines)
Partner Category: Best Use of SerpApi (Grounding multi-agent market research in live Google SERP data)
Partner Category: Best Use of MongoDB Atlas (Using Atlas as the primary data layer for storing user projects, feature void matrices, and persistent chat sessions)

DEV Community: Sumeet Umbalkar

Ghost Terminal: Zero-Latency Local AI Shell Possession

👻 Ghost Terminal (Shell Auto-Possessor)

What I Built

How It Works

Why Open Innovation & Open Weights Matter

Tech Stack

Source Code (ghost.py)

Setup Instructions

PayGuard - Autonomous Payment Security SDK for AI Agents

PayGuard — Autonomous Payment Security SDK for AI Agents

What I Built

How It Fits "Slow and Steady"

Why Open Innovation Matters

Links

Memovable — In-Memory LLM Context Optimization Engine

Memovable — In-Memory LLM Context Optimization Engine

Elevator Pitch

Inspiration

What it does

How we built it

Why Open Innovation Matters for Memovable

Challenges we ran into

Accomplishments that we're proud of

What's next for Memovable

RivalFree: Multi-Agent Competitive Analysis Engine Powered by Gemma & SerpApi

What I Built

Demo

Code

sumeet57 / RivalFree

RivalFree ⚡

🎯 The Problem & Solution

🚀 Key Features

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Source Code (`ghost.py`)