Forem: Lakshmi Sravya Vedantham

I Built a Skill So Claude Automatically Routes Tasks to Free-Tier AI Providers

Lakshmi Sravya Vedantham — Fri, 27 Mar 2026 20:45:03 +0000

I Built a Skill So Claude Automatically Routes Tasks to Free-Tier AI Providers

Here's a problem I kept running into: I have free-tier access to Groq, OpenAI, Gemini, and MiniMax — but managing them manually is painful. Wrong tool for the job, accidentally burning through monthly limits, no visibility into what's been used.

I built agent-hub to fix this. It's a Claude Code skill that makes Claude the orchestrator — every task is automatically classified, routed to the best provider, tracked against free limits, and shown in a live status bar.

How it works

Claude classifies every incoming message into a task type and routes it:

Task Type	Signals	Provider
`code`	write/fix/debug/refactor	Codex (gpt-4o-mini)
`research`	explain/summarize/compare	Gemini (gemini-2.0-flash)
`creative`	story/dialogue/narrative	MiniMax
`fast`	yes/no, quick lookups	Groq
`general`	everything else	Groq

Classification happens before calling any API — router.py checks token budgets in usage.json, picks the best available provider, calls its API, and returns the response.

Auto-fallback: when a provider drops below 10% of its free tier, traffic automatically shifts to its fallback (Groq→Gemini, Codex→Groq, Gemini→MiniMax, MiniMax→Gemini).

Hard stop: if both primary and fallback are exhausted, the router surfaces it to the user and stops. No silent failures.

The status bar

Every response starts with a live usage bar:

[GROQ ●] Groq: 1,240/14,400 · Codex: 77/500 · Gemini: 108K/1M · MiniMax: 220K/1M

● green — above 50% remaining
● yellow — 10–50% remaining
● red — below 10% (fallback active)
○ gray — exhausted

The active provider appears first in brackets. All four counts are always shown.

Free tier limits

Provider	Model	Limit
Groq	llama-3.3-70b-versatile	14,400 req/day
Codex	gpt-4o-mini	500 req/month
Gemini	gemini-2.0-flash	1M tokens/day
MiniMax	abab6.5s-chat	1M tokens/month

Install

SKILL_DIR="$HOME/.claude/plugins/cache/claude-plugins-official/superpowers/5.0.5/skills/agent-hub"
mkdir -p "$SKILL_DIR/tests"
curl -o "$SKILL_DIR/router.py" https://raw.githubusercontent.com/LakshmiSravyaVedantham/agent-hub/main/router.py
curl -o "$SKILL_DIR/SKILL.md" https://raw.githubusercontent.com/LakshmiSravyaVedantham/agent-hub/main/SKILL.md

Then set your keys:

ROUTER="$SKILL_DIR/router.py"
python3 $ROUTER set-key groq gsk_...
python3 $ROUTER set-key codex sk-...
python3 $ROUTER set-key gemini AIza...
python3 $ROUTER set-key minimax ...
python3 $ROUTER set-key minimax-group-id ...

Keys are stored in ~/.claude/agent-hub/.env with chmod 600 — never in code or skill files.

Usage

In any Claude Code session:

superpowers:agent-hub

Claude validates your keys, shows the initial token bar, and from that point every message is classified and routed automatically. You don't think about providers — Claude does.

Or call router.py directly:

python3 $ROUTER route "explain how transformers work" --type research
python3 $ROUTER status
python3 $ROUTER reset groq

Under the hood

router.py is ~530 lines of Python 3.8+, two dependencies (requests, python-dotenv), 61 tests. Auto-reset logic zeros daily counters at UTC midnight and monthly counters on the 1st. Atomic writes to usage.json via .tmp + rename — no partial writes.

What's next

Three-agent coordination — tested with one session, curious how routing behaves when multiple agents compete for the same provider budget
Claude Code hooks integration — auto-register sessions via hooks so the status bar appears without manually invoking the skill
File section locks — paired with agent-comms for per-file, per-section coordination

GitHub: LakshmiSravyaVedantham/agent-hub — Python 3.8+, MIT license.

I Built a Coordination System for Multiple Claude AI Agents — So They Stop Overwriting Each Other

Lakshmi Sravya Vedantham — Fri, 27 Mar 2026 19:17:58 +0000

I Built a Coordination System for Multiple Claude AI Agents — So They Stop Overwriting Each Other

Here's a problem nobody talks about yet but everyone will hit as AI-assisted development scales up: what happens when two Claude agents are working in the same codebase at the same time?

They overwrite each other. Silently. No warnings, no errors — just lost work.

I built a skill to fix this. It's called agent-comms, and it gives Claude agents a shared communication channel so they can coordinate before conflicts happen.

The Problem

I've been running multiple Claude Code sessions simultaneously on a project — one handling frontend UI work, another fixing the backend pipeline. Both intelligent, both fast, both completely unaware the other exists.

The result: one agent refactors a file, the other overwrites it ten seconds later with a different version. Neither agent knows. The work is gone.

The root issue: Claude agents have no shared awareness. Each terminal is its own isolated context. There's no built-in coordination layer.

The Solution: File-Based Agent Communication

The only channel multiple Claude agents share is the filesystem. So that's where I built the communication layer.

agent-comms creates a .agent-comms/ directory in your project root with three JSON files:

.agent-comms/
  registry.json       — who is active right now
  announcements.json  — what files each agent plans to edit (and why)
  messages.json       — direct agent-to-agent messages

A Python script (comms.py) handles all reads and writes — atomic, stale-safe, zero dependencies.

The Protocol

Every agent follows the same lifecycle:

1. Register

python3 $COMMS register researchUI "building dashboard UI components"
python3 $COMMS register Worker1 "fixing backend data pipeline"

2. Announce upfront — before touching any file

python3 $COMMS announce researchUI \
  "src/lib/api.ts|adding stream endpoint" \
  "src/pages/dashboard.tsx|adding real-time chart"

python3 $COMMS announce Worker1 \
  "src/lib/api.ts|fixing broken API call" \
  "src/pages/dashboard.tsx|removing hardcoded mock data"

3. Check for conflicts

python3 $COMMS check-conflicts Worker1

Output:

CONFLICT: researchUI also needs src/lib/api.ts — their reason: adding stream endpoint
CONFLICT: researchUI also needs src/pages/dashboard.tsx — their reason: adding real-time chart component

Two conflicts detected. Before a single file was touched.

4. Negotiate

Worker1 (the later announcer) initiates:

python3 $COMMS send Worker1 researchUI \
  "CONFLICT on api.ts — my change: fixing broken endpoint call on line 34. I should go first since it's a bug fix."

python3 $COMMS send Worker1 researchUI \
  "CONFLICT on dashboard.tsx — removing 3 hardcoded mock arrays. Safe to do before your chart work. Suggest: I go first."

researchUI reads and replies:

python3 $COMMS read-messages researchUI
# FROM [Worker1]: CONFLICT on api.ts...
# FROM [Worker1]: CONFLICT on dashboard.tsx...

python3 $COMMS send researchUI Worker1 \
  "Agreed — go first on both. I'll wait for your DONE broadcast."

5. Worker1 finishes and broadcasts

python3 $COMMS done Worker1 \
  "src/backend/classifier.py" \
  "src/lib/api.ts" \
  "src/pages/dashboard.tsx"

6. researchUI gets the all-clear

python3 $COMMS read-messages researchUI
# FROM [Worker1]: [DONE] Worker1 finished. Modified: src/lib/api.ts, src/pages/dashboard.tsx

researchUI now knows exactly which files were modified and can proceed safely.

Full Terminal Output

Here's the actual output from a real test run:

=== researchUI announces its files ===
[agent-comms] Announced 3 file(s) for 'researchUI'

=== Worker1 announces its files ===
[agent-comms] Announced 3 file(s) for 'Worker1'

=== researchUI checks for conflicts ===
CONFLICT: Worker1 also needs src/lib/api.ts — their reason: fixing broken API call
CONFLICT: Worker1 also needs src/pages/dashboard.tsx — their reason: removing hardcoded mock data

=== Worker1 negotiates ===
[agent-comms] Sent from 'Worker1' to 'researchUI'
[agent-comms] Sent from 'Worker1' to 'researchUI'

=== researchUI reads messages ===
  FROM [Worker1] @ 2026-03-27T19:14:27: CONFLICT on api.ts — fixing broken endpoint call on line 34. I should go first.
  FROM [Worker1] @ 2026-03-27T19:14:27: CONFLICT on dashboard.tsx — removing 3 hardcoded mocks. Suggest: I go first.

=== researchUI agrees ===
[agent-comms] Sent from 'researchUI' to 'Worker1'

=== Worker1 finishes ===
[agent-comms] 'Worker1' done. Broadcast sent to 1 agent(s).

=== researchUI gets the all-clear ===
  FROM [Worker1]: [DONE] Worker1 finished. Modified: src/backend/classifier.py, src/lib/api.ts, src/pages/dashboard.tsx

=== Final status ===
[agent-comms] Active agents: 1 | Unread messages: 0
  [researchUI] building dashboard UI components
    planned files: dashboard.tsx, Chart.tsx, api.ts

Zero overwrites. Zero lost work.

How It's Designed as a Claude Code Skill

The system ships as a SKILL.md — a Claude Code skill file that instructs Claude to follow the agent lifecycle automatically. When you invoke superpowers:agent-comms in a Claude Code session, Claude:

Runs status to see who's active
Auto-assigns itself a name (or asks you to rename it)
Registers itself with its task description
Before any edit session — announces files and checks conflicts
If conflict detected — initiates or responds to negotiation
Every ~10 tool calls — sends a heartbeat
When done — deregisters and broadcasts to all other agents

The SKILL.md protocol:

## Step 2: Announce Upfront (BEFORE any file edit)

Before touching ANY file this session, list every file you plan to edit and why:

python3 $COMMS announce agent-N \
  "path/to/file.ts|reason for editing"

Then immediately check for conflicts:
python3 $COMMS check-conflicts agent-N

If output is CLEAR → proceed.
If output contains CONFLICT → go to Step 3 (negotiation).

Design Decisions

Why file-based?
Claude agents in different terminals share nothing except the filesystem. No sockets, no shared memory, no APIs between them. Files are the only viable channel.

Why upfront announcements instead of locks?
Locks only catch conflicts at the moment of editing — after you've already started work. Announcements catch them before any work begins, when the cost of changing course is zero.

Why negotiation instead of blocking?
Blocking wastes time. Negotiation lets agents make intelligent decisions: "include my change," "I'll go first," or "let's split the file." The agents have context about what they need — use it.

Stale agent cleanup:
Agents that haven't sent a heartbeat in 5 minutes are auto-removed from the registry. If an agent crashes without deregistering, it won't block others indefinitely.

Project-scoped:
.agent-comms/ lives in the project root and is added to .gitignore automatically. Coordination state doesn't belong in git history.

Install

SKILL_DIR="$HOME/.claude/plugins/cache/claude-plugins-official/superpowers/5.0.5/skills/agent-comms"
mkdir -p "$SKILL_DIR/tests"
curl -o "$SKILL_DIR/comms.py" https://raw.githubusercontent.com/LakshmiSravyaVedantham/agent-comms/main/comms.py
curl -o "$SKILL_DIR/SKILL.md" https://raw.githubusercontent.com/LakshmiSravyaVedantham/agent-comms/main/SKILL.md

Then in any Claude Code session working in a shared project:

superpowers:agent-comms

Tests

19 tests covering the full lifecycle:

python3 -m pytest tests/ -v
# 19 passed in 1.83s

What's Next

Three-agent coordination — tested with 2, curious how negotiation chains work at 3+
File section locks — "I own lines 1–80 of this file, you take 81–160"
Integration with Claude Code hooks — auto-register/deregister via session hooks

GitHub

github.com/LakshmiSravyaVedantham/agent-comms

Python 3.8+, stdlib only, MIT license. Drop it into your superpowers skill directory and your agents start coordinating immediately.

If you're running multiple Claude sessions simultaneously, this will save you from the silent overwrite problem sooner or later.

I Built a Tool So Claude Code Can Use My Colab GPU

Lakshmi Sravya Vedantham — Sat, 21 Mar 2026 00:25:49 +0000

The Problem

I use Claude Code daily. It can read my files, run bash commands, edit code — but the moment I need GPU compute, I'm back to copy-pasting between my terminal and Google Colab like it's 2020.

I was working on a Videogen. The image generation runs locally on my Mac, but the model needs a GPU. Every time I wanted to test an image-to-video model, I had to:

Open Colab
Paste my code
Run cells manually
Copy results back
Repeat 50 times

So I built claude-colab — a bridge that gives Claude Code direct GPU access through Google Colab.

How It Works

Colab (T4/A100 GPU)                     Your Machine
┌────────────────────┐                 ┌─────────────────┐
│ Flask API          │◄── HTTPS ──────►│ CLI / MCP Server│
│ E2E Encrypted      │  (cloudflared)  │                 │
│ Bearer token auth  │                 │ Claude Code     │
└────────────────────┘                 │ gains GPU tools │
                                       └─────────────────┘

Three layers:

Colab notebook — Flask API + Cloudflare tunnel on the GPU
CLI — pip install claude-colab, human-friendly commands
MCP server — Claude Code sees GPU tools natively

3-Line Setup

pip install claude-colab
# Open the notebook in Colab, run all cells, copy the connection string
claude-colab connect cc://TOKEN:KEY@your-tunnel.trycloudflare.com

That's it. Claude now has a GPU.

What Claude Can Do

claude-colab status                    # GPU info
claude-colab exec "nvidia-smi"         # Run any command
claude-colab python -c "import torch; print(torch.cuda.get_device_name(0))"
claude-colab upload model.py /content/model.py
claude-colab download /content/results.csv ./results.csv

Or with the MCP server, Claude calls these as tools directly — no copy-paste, no browser tabs.

The Security Part

I didn't want my code traveling through Cloudflare in plaintext. Every request and response body is encrypted with Fernet (AES-128-CBC + HMAC-SHA256) before it hits the tunnel.

Who	Can see	Cannot see
Cloudflare	URL paths, timing	Your code, data, results
Google	Everything on the VM	Your local files
Random internet	Nothing	Everything

The connection string carries both a bearer token (auth) and an encryption key (privacy). Three ways to connect so it never lands in your shell history:

claude-colab connect cc://...          # Direct
claude-colab connect                    # Interactive prompt
pbpaste | claude-colab connect -        # Pipe from clipboard

Real Usage: Testing Video Models

The reason I built this — I needed to test image-to-video models for StoryGen. With claude-colab connected to an A100, I asked Claude to:

Upload a FLUX-generated scene image
Install diffusers + transformers
Load Wan2.1-I2V-14B (14 billion parameters)
Generate an animated clip
Download the result

All from one conversation. No browser. No manual steps.

> claude-colab exec "nvidia-smi --query-gpu=name,memory.total --format=csv"
NVIDIA A100-SXM4-80GB, 81920 MiB

Wan2.1-14B loaded in full fp16, generated 33 frames in 3 minutes. That's the kind of workflow that was impossible before.

The Code

82 tests, 96% coverage, 6 source files:

src/claude_colab/
├── crypto.py       # Fernet E2E encryption
├── config.py       # URI parsing, secure config
├── client.py       # HTTP client (shared by CLI + MCP)
├── cli.py          # Click commands
└── mcp_server.py   # 5 MCP tools for Claude Code

The entire local package has 4 dependencies: click, httpx, cryptography, mcp. No torch, no ML libs — those live on Colab.

Try It

pip install claude-colab

Repo: github.com/LakshmiSravyaVedantham/claude-colab

Open the notebook in Colab, run all cells, paste the connection string. Your AI coding agent now has a GPU.

I Built a Tool to Control AI Coding Agents from My Phone

Lakshmi Sravya Vedantham — Wed, 18 Mar 2026 18:30:06 +0000

The Problem

You're on the couch, in a coffee shop, or just away from your desk. You have a list of coding tasks you want done. You have AI coding agents (Claude Code, Aider, Codex, Gemini CLI) installed on your machine. But you can't use them from your phone.

What if you could just text your tasks from Discord and have multiple AI agents start working on them — each in its own terminal?

What I Built

Agentboard — an open-source tool that lets you orchestrate multiple AI coding agents from your phone via Discord.

You type:

team Alpha: Build a landing page for my portfolio
team Beta: Fix the auth bug in my API
team Gamma: Write tests for the payment module

And on your Mac, three Terminal windows open — each running Claude (or Aider, Codex, Gemini, whatever you configure) working on its assigned task. In parallel.

How It Works

You (Discord on phone)
    |
    v
Discord Bot (Python, runs on your machine)
    |
    +-- Team Alpha -> Terminal.app -> claude "Build landing page..."
    +-- Team Beta  -> Terminal.app -> claude "Fix auth bug..."
    +-- Team Gamma -> Terminal.app -> claude "Write tests..."

You send a message in Discord with team Name: task
The bot parses your message
Opens a real Terminal window per team
Runs your AI coding CLI interactively
Each team works independently, in parallel

No API credits needed for the bot itself — it uses your existing Claude Code subscription (or whatever CLI you have installed).

The Pluggable Backend

Agentboard isn't locked to one AI tool. It works with any CLI:

Backend	Command
Claude Code	`claude "task"`
Aider	`aider --message "task"`
Codex CLI	`codex "task"`
Gemini CLI	`gemini "task"`
Goose	`goose run "task"`
Any CLI	Configure in `agentboard.toml`

Quick Start

# Clone
git clone https://github.com/LakshmiSravyaVedantham/agentboard
cd agentboard/discord-bot

# Setup
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Add your Discord bot token to .env
echo 'DISCORD_BOT_TOKEN=your-token' > ../.env

# Run
python bot.py

Then in Discord:

team Alpha: Build a hello world Python script

A Terminal window opens on your Mac with Claude working on it.

Setting Up the Discord Bot (2 minutes)

Go to Discord Developer Portal
New Application -> name it "Agentboard"
Bot tab -> Reset Token -> copy it
Enable Message Content Intent
OAuth2 -> URL Generator -> scope: bot -> permissions: Send Messages, Manage Channels, Read Message History
Open the generated URL -> add bot to your server

What's Under the Hood

Agentboard also includes a full Rust backend (for those who want it):

17 unit tests covering config, auth, team state machine, backend registry, orchestrator
Axum server with 12 API endpoints + WebSocket
Svelte PWA with dark glassmorphism UI (pairing screen, team dashboard, live terminal output)
JWT auth with 6-digit pairing codes
Pluggable backends via TOML config
Graceful shutdown — SIGTERM to all child processes

The Rust server compiles to a single 7.2MB binary with the frontend embedded via rust-embed.

But honestly? The Discord bot is the killer feature. It's 150 lines of Python and it just works.

Commands

You type	What happens
`team Alpha: Build a landing page`	Opens Terminal with Claude working on it
`team Alpha: Fix auth in ~/myproject`	Opens Terminal in that directory
`status`	Shows all active teams
`kill Alpha`	Kills a team
`help`	Shows all commands

Pick Your Terminal

When you send a task, the bot asks which AI coding tool to use:

Which terminal should I use?
1️⃣ Claude
2️⃣ Codex
3️⃣ Aider
4️⃣ Gemini
5️⃣ Goose
6️⃣ OpenCode

React with a number. Each team can use a different tool if you want.

Split Panes + Named Sessions

Multiple teams open as split panes in the same Terminal window — not separate windows cluttering your desktop. Each Claude session gets a named session (visible in the title bar and /resume), so you always know which team is which.

Discord Channels Per Team

Each team gets its own Discord channel (#team-alpha, #team-beta). Output streams into the channel in real-time, so you can monitor progress from your phone without switching windows.

Why Discord?

I tried building a PWA first. It worked, but:

Localhost firewall issues on phones
Safari blocks Web Speech API without HTTPS
Another app to maintain

Discord just works. It's on your phone, it handles notifications, and your data stays in your private server. The bot is 150 lines of Python with zero infrastructure cost.

What I Learned

Claude Code's --print flag uses API credits, not your subscription. The interactive claude command uses your subscription. Big difference when you're spawning multiple agents.
Multiple Discord bots can pile up. When developing, always pkill -9 -f bot.py before starting a new instance. I had 6 zombie bots responding to the same messages.
The simplest approach wins. I designed an elaborate Rust+Svelte+WebSocket+JWT system. The Discord bot that actually ships is 150 lines of Python that opens Terminal windows. Ship the simple thing.

Try It

Repo: github.com/LakshmiSravyaVedantham/agentboard

Star it if you find it useful. PRs welcome — especially for Linux/Windows terminal support.

Agentboard is open source (MIT). No telemetry, no cloud, no data leaves your machine.

I Stopped Paying $30/month for Video Resizing. Here's the Open-Source Alternative.

Lakshmi Sravya Vedantham — Mon, 16 Mar 2026 17:38:10 +0000

Every social platform wants a different video size.

TikTok wants 9:16. YouTube wants 16:9. Instagram wants 1:1 and 4:5. Twitter wants 16:9 but at 720p. LinkedIn wants 16:9 but allows 10-minute videos.

Cloud tools like OpusClip and Kapwing charge $15-30/month for what ffmpeg can do for free — if you know the 47 flags. I wrapped it all in one Rust command.

The Problem

You record a video. Now you need it on 8 platforms. Each platform has its own:

Aspect ratio
Resolution
Maximum duration
Bitrate sweet spot
Codec preferences

Your options:

Pay Kapwing/OpusClip — $15-30/month, upload your video to their cloud, wait for processing, download 8 versions
Write ffmpeg commands — Free, but you're writing 50+ lines of flags per platform, debugging filter chains, and maintaining a shell script that breaks every time you add a platform
Google's AutoFlip — Was open-source, now deprecated

I built option 4.

The Solution

socialcut input.mp4 --platforms all -o output/

One command. Eight platform-optimized videos. Done.

No cloud upload. No subscription. No account. Your video never leaves your machine.

Platform Presets

socialcut ships with 8 platform presets, each tuned to that platform's requirements:

Platform	Aspect	Resolution	Max Duration	Bitrate
TikTok	9:16	1080x1920	180s	6 Mbps
Instagram Reel	9:16	1080x1920	90s	5 Mbps
Instagram Square	1:1	1080x1080	60s	5 Mbps
Instagram Post	4:5	1080x1350	60s	5 Mbps
YouTube	16:9	1920x1080	none	8 Mbps
YouTube Shorts	9:16	1080x1920	60s	6 Mbps
Twitter	16:9	1280x720	140s	5 Mbps
LinkedIn	16:9	1920x1080	600s	8 Mbps

These aren't guesses. They're pulled from each platform's upload specs and encoding recommendations.

Example Commands

All platforms at once:

socialcut input.mp4 --platforms all -o output/

Just the platforms you need:

socialcut input.mp4 --platforms tiktok,instagram-reel,youtube -o output/

Letterbox mode — preserve everything, add padding:

socialcut input.mp4 --platforms instagram-square --mode letterbox --bg-color "#1a1a2e" -o output/

Burn a caption into the video:

socialcut input.mp4 --platforms tiktok --caption "Check this out!" -o tiktok.mp4

Low quality for quick previews:

socialcut input.mp4 --platforms all --quality low -o preview/

Max quality for the final export:

socialcut input.mp4 --platforms youtube --quality max -o final.mp4

Three Crop Modes

This is where socialcut earns its keep. Converting between aspect ratios is the hard part, and there are three ways to handle it:

1. crop (default) — Fill the frame, cut the edges

Input 16:9           Output 9:16 (TikTok)
+----------------+   +------+
|    |      |    |   |      |
|    | KEEP |    | > |      |
|    |      |    |   |      |
+----------------+   +------+
     crop sides

No black bars. The output fills the entire frame. You lose some edges, but the result looks native to the platform.

Use --gravity to control which part of the frame survives:

--gravity top       --gravity center     --gravity bottom
+----------+        +----------+         +----------+
| KEEP     |        |          |         |          |
|          |        | KEEP     |         |          |
+----------+        |          |         | KEEP     |
|          |        +----------+         |          |
|          |        |          |         +----------+
+----------+        +----------+         +----------+

2. letterbox — Preserve everything, add bars

Input 16:9           Output 1:1 (Instagram)
+----------------+   +----------+
|                |   |##########|
|                | > |  video   |
|                |   |##########|
+----------------+   +----------+
                      # = padding

Nothing gets cropped. Black bars (or any color you choose) fill the empty space. Use this when every pixel matters.

3. fit — Same as letterbox, clearer name

When "letterbox" sounds too technical. Same behavior.

Quality Presets

Preset	Bitrate	Audio	Use Case
low	50% of platform spec	96 kbps	Quick previews, testing
medium	75% of platform spec	128 kbps	Drafts, internal review
high (default)	100% of platform spec	192 kbps	Final exports
max	150% of platform spec	256 kbps	Maximum quality

How It Compares

Feature	socialcut	OpusClip	Kapwing	raw ffmpeg
Price	Free	$15-30/mo	$16-24/mo	Free
Privacy	100% local	Cloud upload	Cloud upload	100% local
Speed	Fast (local)	Upload-dependent	Upload-dependent	Fast (local)
Ease of use	One command	Web UI	Web UI	50-line script
All 8 platforms	One command	Manual each	Manual each	One script each
Offline	Yes	No	No	Yes
Caption burning	Built-in	Yes	Yes	Manual filter chain
Open source	Yes	No	No	Yes (but no presets)

The cloud tools have nicer UIs. But they also have your video on their servers, a monthly fee, and a dependency on their uptime.

The Info Command

Before you process anything, check what you're working with:

socialcut info input.mp4

Instant metadata: resolution, duration, codec, fps, bitrate. No processing, just ffprobe under the hood.

The Privacy Angle

Your video never leaves your machine. Period.

No cloud upload. No "processing on our servers." No terms of service granting usage rights to your content. No wondering what happens to that unreleased video you're editing.

socialcut shells out to ffmpeg on your local machine. That's it. If your internet goes down, socialcut still works.

Architecture

CLI (clap) > probe (ffprobe) > processor (ffmpeg) > output files
                                      |
                                  platform presets
                                  quality presets
                                  crop calculation
                                  filter chain builder

Five modules, each doing one thing:

platform.rs — 8 platform presets with aspect ratios, resolutions, durations, bitrates
probe.rs — ffprobe wrapper for video metadata extraction
processor.rs — crop/letterbox math, ffmpeg filter chain builder
caption.rs — drawtext filter construction with proper escaping
quality.rs — bitrate multipliers and CRF values

Built in Rust. 71 tests passing. No C bindings to ffmpeg — it shells out, which means if ffmpeg works on your system, socialcut works.

Try It

git clone https://github.com/LakshmiSravyaVedantham/socialcut.git
cd socialcut
cargo install --path .

# Requires ffmpeg
# macOS: brew install ffmpeg
# Ubuntu: apt install ffmpeg

socialcut input.mp4 --platforms all -o output/

Star the repo if this saves you a subscription: github.com/LakshmiSravyaVedantham/socialcut

Your video. Your machine. Your formats. No cloud required.

I Generate $50 Stock Videos With One Command. Here's the Open-Source Tool.

Lakshmi Sravya Vedantham — Mon, 16 Mar 2026 17:37:43 +0000

Stock footage sites charge $15–50 for a single looping background video.

Gradient flows. Plasma effects. Aurora animations. The kind of stuff streamers use behind their webcam, designers drop into hero sections, and indie devs layer behind title screens.

I got tired of paying for something a computer can generate from math. So I built loopkit — a single Rust binary that generates perfectly seamless looping videos from the command line.

loopkit generate --preset plasma --duration 5 -o plasma_loop.mp4

That's it. One command. Full HD. Perfectly looping. Free.

The Problem

You need a looping background video. Your options:

Pay per clip — Shutterstock, Adobe Stock, Envato. $15–50 each. Licensing restrictions. Watermarks until you pay.
Learn After Effects — Steep learning curve for something that should be simple.
Use Processing/TouchDesigner — Great tools, but heavy setup and a runtime to manage.
Find free clips on Pexels — Limited selection, everyone uses the same ones.

None of these feel right for something that is, fundamentally, math applied to pixels over time.

The Solution

loopkit ships as a single binary. No Python. No Node. No runtime. Install it, run one command, get an MP4.

# Install from source
git clone https://github.com/LakshmiSravyaVedantham/loopkit.git
cd loopkit
cargo install --path .

Prerequisites: Rust 1.70+ and ffmpeg (for encoding).

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

5 Built-In Presets

Every preset produces a different visual effect. All of them loop seamlessly.

Plasma

Classic sine wave interference pattern with shifting rainbow hues. Think 90s demoscene.

loopkit generate --preset plasma --duration 5 --fps 30 -o plasma.mp4

Gradient

Smooth flowing gradient that morphs between deep blues, purples, and roses. Clean and modern — perfect for hero section backgrounds.

loopkit generate --preset gradient --duration 8 --fps 24 -o gradient.mp4

Aurora

Northern lights simulation with swaying curtains of green and teal. Organic, atmospheric movement.

loopkit generate --preset aurora --duration 6 --fps 30 -o aurora.mp4

Waves

Layered ocean surface with blue/teal waves and white foam highlights. Calming and rhythmic.

loopkit generate --preset waves --duration 5 --fps 30 -o waves.mp4

Fire

Turbulent fire and lava with orange, red, yellow palette and white-hot core. High energy.

loopkit generate --preset fire --duration 4 --fps 30 -o fire.mp4

Generate All At Once

for preset in plasma gradient aurora waves fire; do
  loopkit generate --preset $preset --duration 5 -o "${preset}_loop.mp4"
done

How Seamless Loops Actually Work

This is the key insight that makes loopkit possible.

Most people try to make loops by blending the last few frames into the first few frames. Cross-fading. It works, but you can usually spot the seam — there's a subtle "pulse" where the blend happens.

loopkit does something different: it never creates a seam in the first place.

Instead of parameterizing time as a linear ramp (0 to 1), we parameterize it as an angle on a circle (0 to 2pi):

        cos=1
         |
         |
sin=-1 --+-- sin=1
         |
         |
        cos=-1

Frame 0 starts at angle 0 (top of circle)
Frame N ends at angle 2pi (back to top)

Since sin(0) = sin(2pi) and cos(0) = cos(2pi), the first frame and last frame are mathematically identical. Not "close enough" — identical. Zero seam. Zero blend artifact.

Here's the actual code:

let phase = (frame as f64 / total_frames as f64) * 2.0 * PI;
let t1 = phase.sin();  // circular time component 1
let t2 = phase.cos();  // circular time component 2

Every preset receives t1 and t2 as its time inputs. The pattern evolves through a complete cycle on the unit circle and returns exactly to its starting state.

Each preset then combines these circular time parameters with spatial coordinates (pixel x, y) through layered sine and cosine functions to produce organic, evolving patterns.

Custom Resolution

Need vertical video for TikTok or Instagram Reels? Just flip the dimensions:

# 1080x1920 vertical video
loopkit generate --preset gradient --duration 8 --width 1080 --height 1920 -o vertical.mp4

# 4K for the big screen
loopkit generate --preset aurora --duration 10 --width 3840 --height 2160 -o aurora_4k.mp4

# Quick 720p preview
loopkit generate --preset fire --duration 3 --width 1280 --height 720 -o preview.mp4

Architecture

src/
  main.rs          CLI entry point (clap)
  lib.rs           Public API
  color.rs         HSL-to-RGB conversion, color interpolation
  renderer.rs      Frame generation + ffmpeg encoding
  presets/
    mod.rs         Preset trait + registry
    plasma.rs      Sine wave interference
    gradient.rs    Flowing color gradients
    aurora.rs      Northern lights
    waves.rs       Ocean waves
    fire.rs        Fire/lava

The rendering pipeline:

Parse CLI arguments with clap
Look up the preset function from the registry
For each frame: compute t1, t2 from the circular phase, render every pixel
Save frames as PNGs in a temp directory
Shell out to ffmpeg to encode PNGs into an MP4
Clean up the temp directory

16 tests. All passing.

cargo test

Why Rust?

I could have built this in Python with Pillow. I chose Rust for three reasons:

1. Single binary. cargo install and you're done. No virtualenv, no pip install, no "which Python version do I need?" — just a binary in your PATH.

2. Speed. A 5-second 1080p video at 30fps means 150 frames. Each frame is ~2 million pixels. That's 300 million pixel computations. Rust handles this without flinching. Try that in Python and go make coffee.

3. No runtime. The only external dependency is ffmpeg for the final encoding step. Everything else — frame generation, color math, preset logic — is compiled into the binary.

Try It

git clone https://github.com/LakshmiSravyaVedantham/loopkit.git
cd loopkit
cargo install --path .
loopkit generate --preset plasma --duration 5 -o my_first_loop.mp4

Star the repo if this is useful: github.com/LakshmiSravyaVedantham/loopkit

Ideas for contributions:

New presets (starfield, geometric patterns, noise landscapes)
Parallel frame rendering with rayon
Custom color palettes via CLI
GIF output option
Preview mode (single frame to PNG)

Stock footage sites are charging $50 for math. Now you have the math for free.

I Piped My Server Logs Into a Video and Found the Bug in 10 Seconds

Lakshmi Sravya Vedantham — Mon, 16 Mar 2026 17:37:06 +0000

What if you could see your data instead of reading it?

I was tailing an access log at 2 AM, trying to find a latency spike buried in 50,000 lines of text. Scrolling. Grep. More scrolling. Then I piped the same log into a tool I'd been building, and the spike jumped out of a heatmap video in ten seconds flat.

That tool is vizpipe.

The Concept

Unix pipes are the most powerful abstraction in computing. You can chain grep, awk, sort, uniq — transforming data through a pipeline that reads left to right like a sentence.

But pipes always end in text. What if they ended in video?

stdin | vizpipe → MP4

That's the entire idea. vizpipe reads numbers from stdin and renders them as an animated video. No browser. No JavaScript. No dashboard. No accounts. Just a pipe and an MP4 file.

5 Commands That Changed How I Look at Data

1. Count to 50, watch it grow

seq 1 50 | vizpipe --mode bars -o bars.mp4

Each number becomes a bar. The video builds up frame by frame. You see the data accumulate.

2. CSV trend line

cat sales.csv | vizpipe --mode line --column 2 -o trend.mp4

Extract column 2 from a CSV and draw a self-animating line chart. The line draws itself as data flows in.

3. Log latency heatmap

cat access.log | vizpipe --mode heatmap --pattern '\\d+ms' -o latency.mp4

Regex extracts millisecond values from log lines. The heatmap lights up — and you see where the spikes cluster.

4. Real-time ping monitoring

ping -c 20 google.com | vizpipe --mode gauge --pattern 'time=(\\d+\\.?\\d*)' -o ping.mp4

A circular gauge that responds to each ping result. Satisfying and immediately useful.

5. Random scatter

shuf -i 1-100 -n 200 | vizpipe --mode scatter -o random.mp4

200 random points appearing one by one on a 2D plane. Simple but hypnotic.

How It Works

stdin --> Parser --> Visualizer --> Renderer --> ffmpeg --> .mp4
           |            |              |
           |            |              +-- PNG frames in temp dir
           |            +-- Trait: bars/line/scatter/gauge/heatmap
           +-- Regex, CSV, JSON, key=value, raw numbers

Three stages:

Parser reads stdin line by line and extracts numeric values. It auto-detects format — raw numbers, CSV, JSON, key=value pairs — or you can specify a regex with --pattern.
Visualizer maintains state and renders each frame showing all data seen so far. This creates the "buildup" animation effect.
Renderer generates PNG frames in a temp directory, then shells out to ffmpeg to encode them as MP4.

No external font dependencies. Text is rendered using a built-in 5x7 bitmap font drawn as rectangles. vizpipe works on any system without font configuration.

5 Visualization Modes

Mode	What it does	Best for
`bars`	Animated bar chart, color-coded by magnitude	Comparing values, rankings
`line`	Self-drawing line graph with fill	Time series, trends
`scatter`	Points appear one by one on a 2D plane	Distributions, correlations
`gauge`	Circular speedometer	Single-metric monitoring
`heatmap`	Color-coded 2D grid	Frequency analysis, density

5 Color Schemes

Scheme	Vibe
`default`	Blue to red gradient
`neon`	Cyan/magenta/yellow on dark
`ocean`	Cool blues and teals
`sunset`	Warm oranges and purples
`mono`	White on black, clean

seq 1 100 | vizpipe --mode bars --color-scheme neon --bg-color "#0a0a0a" -o neon.mp4

Data Format Auto-Detection

vizpipe doesn't care what your data looks like. It figures it out.

Format	Example	Detection
Raw numbers	`42`, `3.14`	Automatic
Space/comma separated	`10 20 30`	Automatic
CSV	`name,42,high`	Use `--column N`
JSON	`{"latency": 42}`	Automatic (top-level numerics)
Key=value	`cpu=85% mem=72%`	Automatic
Regex	`time=42.3ms`	Use `--pattern`

Why This Matters

Data visualization shouldn't require:

Opening a browser
Writing JavaScript
Setting up Grafana
Creating an account on some SaaS
Uploading data to a third party

Sometimes you just want to look at your data. Pipe in, get video out. That's it.

The Unix philosophy says: do one thing well, accept stdin, produce output. vizpipe follows that philosophy — except the output is an MP4 instead of text.

The Stack

Written in Rust using the image and imageproc crates for frame rendering. Video encoding via ffmpeg. 68 tests. Zero runtime dependencies beyond ffmpeg.

Why Rust? Because when you're generating hundreds of PNG frames and encoding video, speed matters. vizpipe processes data and renders frames fast enough that the bottleneck is ffmpeg, not the renderer.

Try It

# Install from source
git clone https://github.com/LakshmiSravyaVedantham/vizpipe.git
cd vizpipe
cargo install --path .

# Requires: Rust 1.70+, ffmpeg

# Your first visualization
seq 1 50 | vizpipe --mode bars -o first.mp4

Star it if this is useful: github.com/LakshmiSravyaVedantham/vizpipe

Every pipe deserves a picture.

I Never Record Code Reviews Anymore — My Rust Tool Turns Any Git Diff Into a Video

Lakshmi Sravya Vedantham — Mon, 16 Mar 2026 17:36:50 +0000

Code reviews are the most text-heavy part of software development. Walls of green and red. Inline comments. "LGTM" after skimming 400 lines.

What if you could watch a code review instead of reading it?

The Problem Nobody Talks About

Async code reviews lose context. You're staring at a diff, jumping between files, trying to reconstruct the story of the change. Why was this deleted? What does this new function connect to?

Video walkthroughs solve this. Senior engineers record Loom videos walking through PRs all the time. But recording takes 10x longer than writing comments. You have to:

Open a screen recorder
Navigate to each file
Talk through every change
Edit out the "uh"s and wrong tabs
Upload and share

Nobody does this for every PR. So we're stuck with text diffs.

One Command. Animated Walkthrough.

patchcast --diff HEAD~1 -o review.mp4

That's it. PR URL in, MP4 out.

patchcast reads any git diff — commit ranges, branch comparisons, .diff files — and generates an animated code walkthrough video with real syntax highlighting, smooth transitions, and a professional dark-theme aesthetic.

No recording. No narration. No editing. The diff is the video.

How the Animation Works

Each file in the diff becomes a scene. The animation follows a deliberate sequence designed for readability:

1. Title Card (1s) — Filename, language, change stats (+N/-N). You immediately know what file you're looking at and how big the change is.

2. Code Reveal — Lines appear progressively with full syntax highlighting. Not a screenshot — real parsed syntax via syntect, supporting 30+ languages.

3. Deletion Highlight — Removed lines pulse red and fade out. Your eye is drawn exactly where code was removed.

4. Addition Highlight — New lines slide in with a green highlight, then normalize. The visual weight tells you "this is what matters."

5. Pause (0.5s) — Hold the final state so you can actually read it.

6. Crossfade (0.5s) — Smooth transition to the next file.

Title Card → Code Reveal → Deletions (red) → Additions (green) → Pause → Crossfade → Next File

The result: a video that tells the story of a change, file by file, in the order that makes sense.

Real Commands

# Review your last commit
patchcast --diff HEAD~1 -o review.mp4

# Compare branches (perfect for PR walkthroughs)
patchcast --diff main..feature-branch -o pr.mp4

# Use a diff file with a custom theme
patchcast --file changes.diff --theme "Solarized (dark)" -o styled.mp4

# Full customization
patchcast --diff HEAD~1 \
  --theme "Solarized (dark)" \
  --font-size 18 \
  --fps 30 \
  --width 1920 --height 1080 \
  -o review.mp4

# Pipe from git
git diff main | patchcast --file /dev/stdin -o out.mp4

Where This Actually Gets Used

Async code reviews — Drop a video in the PR thread. Reviewers watch the change unfold instead of scrolling a diff. Context survives the async gap.

Onboarding — New engineer joins? Generate videos of the last 10 meaningful PRs. They watch the codebase evolve instead of reading stale wiki pages.

Tech talks and demos — Need to show a refactor in a presentation? One command, polished video. No screen recording, no "let me zoom in on this part."

Documentation — Embed walkthrough videos in architecture docs. Show how the system changed, not just what it looks like now.

Blog posts — Writing about a technique? Generate a video of the actual code change instead of pasting static snippets.

Under the Hood

patchcast is written in Rust. The pipeline is straightforward:

diff input → parse → syntax highlight → scene generation → frame rendering → ffmpeg → MP4

diff_parser.rs — Parses unified diff format into structured hunks
highlighter.rs — syntect-based syntax highlighting for 30+ languages
scene.rs — Converts parsed diffs into animation scenes with timing
animation.rs — Easing functions, interpolation, timing curves
renderer.rs — Renders frames using the image crate, pipes to ffmpeg
style.rs — Dark theme (Catppuccin Mocha inspired), color constants

The syntax highlighting is real — not regex-based approximation. syntect uses the same .sublime-syntax definitions that power Sublime Text and bat. Rust, Python, JavaScript, TypeScript, Go, Java, C++, Ruby, Swift, and 20+ more languages are highlighted correctly out of the box.

59 tests cover the full pipeline from diff parsing to frame generation.

Why Rust?

Frame rendering is CPU-intensive. Each frame is a pixel buffer that needs text layout, color blending, and composition. Rust makes this fast without a garbage collector pause mid-render. A typical 5-file diff renders in seconds.

The image crate handles pixel-level rendering. git2 (libgit2 bindings) reads the repository directly — no shelling out to git. syntect provides the highlighting. ffmpeg handles the final encoding.

Try It

git clone https://github.com/LakshmiSravyaVedantham/patchcast
cd patchcast
cargo install --path .

# Prerequisites: Rust 1.70+, ffmpeg
# macOS: brew install ffmpeg
# Ubuntu: apt install ffmpeg

Then point it at any repo:

cd your-project
patchcast --diff HEAD~1 -o walkthrough.mp4

Star the repo if this is useful: github.com/LakshmiSravyaVedantham/patchcast

Code reviews shouldn't require a recording studio. They should require one command.

I Built an AI Video Director That Turns Lessons Into Animated Videos

Lakshmi Sravya Vedantham — Sun, 15 Mar 2026 20:58:11 +0000

I run a kids' educational YouTube channel. Every video needs animations, voiceover, music, and careful editing — which means expensive software and hours of work per upload. Most teachers and content creators I know have the same problem: great lesson ideas, no way to turn them into videos.

I built CutTo to fix this. You describe a lesson in a conversation — "explain how volcanoes erupt for 8-year-olds" — and CutTo writes the script, generates animated visuals, adds voiceover with lipsync, and delivers a finished MP4 you can upload directly.

How it works

Talk to the director — CutTo's AI has a creative director persona. It reacts to your ideas with enthusiasm: "I'm seeing this as a cinematic journey into the earth — layers peeling away, magma rising..." It shapes your rough idea into a visual plan.
See preview images inline — As you plan, Gemini generates preview images directly in the conversation using interleaved text + image output. You see what the AI is thinking before committing to anything.
Edit the scene plan — An interactive editor lets you modify narration, reorder scenes, change speakers, and ask the AI for revisions in natural language: "make the eruption more dramatic."
Watch it generate — Real-time progress tracking shows each scene being animated in parallel. If a scene fails, the pipeline gracefully continues with the rest.
Download your video — Multi-character voices, lipsync on close-ups, mood-matched background music. Ready to upload.

CutTo supports 6 video categories: animated stories, science explainers, documentaries, tutorials, marketing videos, and motivational pieces. The project has 119 automated tests covering the pipeline, services, agent, and API.

The real use case: kids' education

Here's why this matters to me personally. My YouTube channel targets kids ages 6-12. A typical video — "How does the heart pump blood?" — requires:

Writing a kid-friendly script
Finding or creating animated visuals
Recording voiceover (or hiring someone)
Adding background music
Editing everything together in Premiere/DaVinci

That's 4-8 hours per video minimum, or $200+ if I outsource it.

With CutTo, I describe the lesson, review the scene plan, and click generate. The entire process takes one conversation. The AI handles the creative direction, visual generation, voice synthesis, and assembly.

The tech stack

Component	Technology
Conversation + Planning	Gemini 2.5 Flash (interleaved text + image)
Video Generation	Veo 3.0 (cinematic clips) with FLOW prompt decomposition
Image Fallback	Imagen 4.0 + Gemini native image
Voice Synthesis	Google Cloud TTS (Journey/Chirp3 HD) + edge-tts
Lipsync	Wav2Lip
Assembly	FFmpeg (Ken Burns, concat, music mixing)
Agent Framework	Google ADK (3 specialized agents)
Backend	Python 3.11, FastAPI, WebSocket
Frontend	React 18, Vite 5, Web Speech API
Deployment	Docker (multi-stage), Google Cloud Run

Architecture

User speaks lesson idea
    |
    v
Gemini generates scene plan with inline preview images
    |
    v
Interactive scene editor (edit, reorder, revise with AI)
    |
    v
FLOW Prompt Decomposition (subject/action/camera/lighting/palette/texture)
    |
    v
Pipeline: Veo 3.0 -> TTS -> FFmpeg crossfade -> Final MP4
(staggered parallel batches, circuit breaker on failures)

The ADK multi-agent architecture uses three specialized agents:

Creative Director — shapes the vision, asks clarifying questions
Storyboard Artist — generates structured scene plans with visual prompts
Orchestrator — routes between agents based on conversation state

Each agent has its own tools and system instructions. The Creative Director has access to image generation for inline previews; the Storyboard Artist outputs structured JSON that feeds directly into the video pipeline.

What I learned

Gemini's interleaved output is the killer feature for creative tools. Showing preview images during the conversation — not after — makes planning feel immediate. The user sees what the AI is imagining and can redirect before any expensive generation happens.

Visual consistency requires engineering. I use a "visual style anchor" — a detailed description of art style, color palette, and character appearances — prepended to every scene's visual prompt. Combined with Veo's seed parameter (all scenes share a seed derived from video_id), characters and style stay consistent across scenes.

Audio-video sync is harder than it looks. I implemented two modes: audio-driven (default — preserves natural voice speed, video adjusts) and video-driven (audio speeds up or pads to match video length). Getting FFmpeg's atempo chaining right for ratios > 2x was the trickiest bug in the project.

The persona makes the product. A generic "video generator" feels like a tool. A creative director with opinions and enthusiasm feels like a collaborator. The difference is entirely in the system prompt and conversation design.

Try it yourself

git clone https://github.com/LakshmiSravyaVedantham/cutto.git
cd cutto
pip install -r backend/requirements.txt
cd frontend && npm install && npm run build && cd ..
cp -r frontend/dist static
echo "GOOGLE_API_KEY=your-key" > .env
uvicorn backend.main:app --reload --port 8000

Open http://localhost:8000, click a quick-start template like "How the heart pumps blood", and watch the AI direct your video.

GitHub Repo | MIT License

Youtube demo

Built for the Google Gemini Live Agent Challenge (Creative Storyteller category). Every existing tool makes you the editor. CutTo makes you the director.

I Built a Breach Monitoring System That Runs in Your Terminal

Lakshmi Sravya Vedantham — Thu, 12 Mar 2026 19:29:09 +0000

I Built a Breach Monitoring System That Runs in Your Terminal

Most people check if they've been breached once, maybe twice. Then they forget about it. Meanwhile, new breaches happen every week.

I built leakwatch — a personal breach monitoring system that watches your accounts continuously and only alerts you when something new happens.

What it does

pip install leakwatch

# Add accounts to your watchlist
leakwatch watch personal@gmail.com
leakwatch watch work@company.com
leakwatch watch your_username

# Scan for new breaches
leakwatch scan

The key word is new. leakwatch remembers what it has already told you about. It only alerts on breaches it has not seen before.

The dashboard

leakwatch dashboard

Shows your watchlist, new alerts with severity scores (1-10), pending actions, and overall stats. Everything in a clean terminal UI.

How it is different from Have I Been Pwned

Feature	HIBP	leakwatch
Check email	Yes	Yes
Check username	No	Yes
Remember previous results	No	Yes
Only show NEW breaches	No	Yes
Generate action plan	No	Yes
Track your progress	No	Yes
Severity scoring	No	Yes (1-10)
Works offline	No	Yes

Action tracking

Every breach generates prioritized actions. CRITICAL for password leaks, HIGH for PII exposure, MEDIUM for email-only leaks.

leakwatch actions
leakwatch done 3
leakwatch status

Password checker

leakwatch check-password

Uses k-anonymity. Only 5 characters of the hash leave your machine.

Everything stays local

Built-in database of 30+ major breaches. Optional HIBP API key for real-time data. SQLite for all tracking. No cloud, no accounts, no telemetry.

Try it

pip install leakwatch
leakwatch watch your-email@gmail.com
leakwatch scan
leakwatch dashboard

GitHub: github.com/LakshmiSravyaVedantham/leakwatch

This completes my privacy tools trilogy:

trackmap — map which companies track your browsing
phantom — find ghost accounts on breached services
leakwatch — monitor your accounts for new breaches

All open source. All fully local. All pip-installable.

Want all three in a single binary?

I rewrote trackmap + phantom + leakwatch as one Rust binary: privacykit

cargo install privacykit
privacykit track scan --chrome
privacykit phantom scan you@gmail.com
privacykit leak scan

Zero Python. Zero dependencies. One binary.

You Have Accounts on 34 Services You Forgot About. 8 Were Breached.

Lakshmi Sravya Vedantham — Thu, 12 Mar 2026 19:28:13 +0000

Remember that Canva account from 2019? The MySpace one from way back? That random forum you signed up for once?

Those accounts are still out there. And many of them have been breached — passwords leaked, email addresses sold, personal data floating around dark web dumps.

I built phantom to find them.

What it does

pip install phantom-accounts
phantom scan you@gmail.com

╭──────── GHOST ACCOUNT REPORT ────────╮
╰──────────────────────────────────────╯

  ⚠ you@gmail.com  12 breaches

    █ Adobe          2013-10-04  adobe.com
      Exposed: Passwords, Email addresses, Password hints

    █ Yahoo          2013-08-01  yahoo.com
      Exposed: Email addresses, Names, Passwords, Phone numbers

    █ LinkedIn       2021-06-22  linkedin.com
      Exposed: Email addresses, Names, Phone numbers

╭─ SUMMARY ────────────────────────────╮
│  Ghost accounts found: 12 services   │
│  Password leaks: 5                   │
│  Run phantom actions to fix them.    │
╰──────────────────────────────────────╯

It doesn't just find breaches — it tells you what to DO

That's the key difference. Plenty of tools tell you "you were breached." phantom generates a prioritized action plan:

phantom actions

  ID  Priority    Service     Action
  1   CRITICAL    Adobe       Change password
  2   CRITICAL    Yahoo       Change password
  3   HIGH        Adobe       Enable 2FA
  4   HIGH        LinkedIn    Enable 2FA
  5   HIGH        Marriott    Review account (PII exposed)

Then you track your progress:

phantom done 1    # mark as completed
phantom skip 5    # skip if not applicable
phantom status    # see overall progress

Password checker

Check if a password has been seen in any data breach — using k-anonymity so your actual password never leaves your machine:

phantom check-password
Enter password to check: ****
⚠ Password p4****** has been seen 847 times in data breaches.
Change this password immediately.

How it works

Built-in database of 20+ major breaches covering 3 billion+ accounts
Optional HIBP API integration for real-time results
Actions auto-generated based on what was exposed (passwords = CRITICAL, PII = HIGH)
Local SQLite database tracks your response progress
Everything runs on your machine

Try it

pip install phantom-accounts
phantom scan your-email@gmail.com
phantom actions

GitHub: github.com/LakshmiSravyaVedantham/phantom

Part of my privacy tools suite. Also check out trackmap (map your tracking network) and leakwatch (continuous breach monitoring).

Want all three in a single binary?

I rewrote trackmap + phantom + leakwatch as one Rust binary: privacykit

cargo install privacykit
privacykit track scan --chrome
privacykit phantom scan you@gmail.com
privacykit leak scan

Zero Python. Zero dependencies. One binary.

Google Can See 78% of Your Browsing History — I Built a Tool to Prove It

Lakshmi Sravya Vedantham — Thu, 12 Mar 2026 19:28:10 +0000

Every website you visit is quietly loading invisible scripts from tracking companies. Ad networks, analytics platforms, fingerprinting services — they're all there, stitching together a profile of you across every site you touch.

I wanted to know exactly who's watching. So I built trackmap.

What it does

pip install trackmap
trackmap scan --chrome

trackmap reads your browser history (Chrome, Firefox, or Safari), fetches each site, extracts every third-party script, pixel, and iframe, and maps out which companies are tracking you.

TRACKING NETWORK REPORT
━━━━━━━━━━━━━━━━━━━━━━
Sites scanned:    87
Trackers found:   23 companies across 312 connections

TOP TRACKERS BY REACH
  Google                    ██████████████████░░  78.2% of your browsing
  Meta                      █████████░░░░░░░░░░░  41.3%
  Amazon                    ██████░░░░░░░░░░░░░░  29.1%
  Oracle                    ████░░░░░░░░░░░░░░░░  18.4%
  Criteo                    ███░░░░░░░░░░░░░░░░░  14.9%

How it works

Import your browser history from Chrome/Firefox/Safari
Scan the top 100 most-visited sites (async, fast)
Extract every third-party domain from scripts, iframes, pixels, inline URLs
Match against a built-in database of 163 tracker domains from 72 companies
Report with bar charts, categories, and a privacy risk score

Five categories: Advertising, Analytics, Social, Fingerprinting, and Content delivery.

The scariest part

It's not just that Google tracks you. It's that companies you've never heard of — Criteo, BlueKai, LiveRamp — are embedded across dozens of your most-visited sites, building a shadow profile of your interests, habits, and behavior.

trackmap also shows unknown third-party domains that aren't in any tracker database. These are potential new trackers that haven't been catalogued yet.

Privacy

Your history never leaves your machine
All scanning happens locally
No API keys needed
Works on a copy of your browser DB (doesn't touch the original)

Try it

pip install trackmap
trackmap scan --chrome --top 50

Or check if a specific domain is a known tracker:

trackmap check doubleclick.net

GitHub: github.com/LakshmiSravyaVedantham/trackmap

This is part of a privacy tools suite I'm building. Also check out:

shadowscan — what AI can see about you locally
datawipe — automate GDPR/CCPA data deletion requests
consentmap — privacy policy scanner
phantom — find your ghost accounts on breached services

Want all three in a single binary?

I rewrote trackmap + phantom + leakwatch as one Rust binary: privacykit

cargo install privacykit
privacykit track scan --chrome
privacykit phantom scan you@gmail.com
privacykit leak scan

Zero Python. Zero dependencies. One binary.