DEV Community: Kaif Ansari

The First Time My AI Agent Sent an Email to the Wrong Person — And Why I Finished It Anyway

Kaif Ansari — Fri, 13 Nov 2026 03:00:04 +0000

"An agent that can't be interrupted mid-task is a demo. One that can — that's a product."

The first time my AI agent tried to send an email to the wrong person, I didn't know how to stop it.

I was six steps into a multi-step task. The message was already drafted. The AgenticBrain was about to hit send. I said: "No — not WhatsApp, email him. Kaif13018@gmail.com."

And it just... stopped. Replanned. Switched tools. Kept the project work it had already completed. Sent the email to the right address.

That moment taught me something no tutorial would have: an agent that can't be interrupted mid-task is a demo. One that can — that's a product.

I'm Kaif. Over the last 14 months I've been building JARVIS OS Agent — an open-source autonomous AI operating system for Windows — on a 2012 Intel i5-3210M with 4GB RAM.

This post is about how to install it on your machine. But first, I want to show you what makes it different — because installing yet another "autonomous agent" without knowing why is a waste of your afternoon.

What JARVIS Actually Does (And Why It Took 14 Months)

Most "autonomous agents" on GitHub are ChatGPT API wrappers with a fancy README. They run a plan, and if something goes wrong, you either wait or kill the process.

JARVIS is different in four specific ways:

1. The loop is genuinely interruptible.
Change your mind mid-task — the plan re-plans in place, completed steps stay intact. No restart. No hallucinated apology loop. This is what took the longest to get right.

2. Memory is a five-tier system, not a chat log.
Rolling episodic history (2 days raw + 13 days summarized), weighted semantic graph with temporal decay, hybrid BM25 + vector RAG, TTL ephemeral state, and a semantic behavioral pattern engine. All running on local embeddings — no cloud calls, no quotas, no cost.

3. It reaches out proactively — but asks before acting.
Background listeners catch emails, WhatsApp messages, PC health alerts. When something needs attention, the agent pauses, explains the context, and waits for your consent. HITL confirmation gates are enforced at the IPC layer, not the prompt — the agent cannot auto-approve its own outgoing messages.

4. Tool integration is plug-and-play via MCP.
18,000+ external servers — GitHub, Brave, SQLite, Notion, Docker. Add one with a single CLI command. Hot-reloads in 2 seconds. No restart, no code edits.

Plus: Android control via Termux, Telegram remote bot, dual-engine voice (Azure + Vosk), and four independent UI overlays (Agent Panel, Typing Popup, STT Popup, Input Popup) with a Unified Portal web dashboard at http://127.0.0.1:8000.

The Constraint That Shaped Everything

Here's the part I want to be honest about: I didn't build JARVIS despite my hardware. I built it because of it.

I had no GPU. I had no 32GB workstation. I had a laptop that struggled to load YouTube without lag.

So every architectural decision became a negotiation with that constraint:

Cloud LLMs for reasoning — the hard thinking happens on Groq/OpenRouter, not on my CPU
BAAI/bge-small-en-v1.5 — 33M parameter embedding model instead of 300M+ alternatives. Runs on CPU. Zero cloud calls.
ONNX-based RapidOCR — no PyTorch dependency for GUI automation
UIA-first detection — OCR only fires when native accessibility APIs return too few elements
Lazy service boot — WhatsApp, Telegram, mobile bridges, MCP servers all skip startup entirely if not authenticated

The result: boots in ~50 seconds on any Windows machine from the last decade. Runs comfortably on modest hardware. Actually usable.

That's not a flex. That's just what happens when you can't throw hardware at a problem.

Prerequisites

Requirement	Why
Windows 10 or 11	JARVIS uses Windows-specific APIs for GUI automation
Python 3.10+	Core runtime (installer auto-installs if missing)
Node.js 18+	WhatsApp bridge and MCP servers (24+ recommended)
~2 GB free disk	Embedding model (~130 MB) + dependencies
One LLM API key	Groq is free and fast — get one here

No GPU. No Docker. No CUDA toolkit. Just Windows, a terminal, and an internet connection.

Step 1: The One-Command Install (5 Minutes)

Open PowerShell (the blue one, not CMD) and paste this:

Set-ExecutionPolicy Bypass -Scope Process -Force; [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; & ([scriptblock]::Create((Invoke-RestMethod -Uri 'https://github.com/thekaifansari01/Jarvis-OS-Agent/releases/latest/download/install.ps1')))

Here's what my installer actually does — so you know exactly what you're running:

Checks if Git, Python 3.11, and Node.js are installed — if not, installs them via winget
Clones the repo to %USERPROFILE%\Jarvis-OS-Agent
Creates a Python virtual environment with CPU-optimized PyTorch (I deliberately avoid the 2GB CUDA version — most people don't have NVIDIA GPUs)
Installs the WhatsApp Baileys bridge via npm install
Prompts you for API keys interactively
Registers the jarvis command globally

☕ First run takes 5–10 minutes. ~40 Python packages + a 130MB embedding model. Windows might show a UAC prompt for the Visual C++ Redistributable — accept it.

Once it finishes, open a NEW terminal (the current one won't have the updated PATH) and run:

jarvis

You should see the ASCII banner and a status line confirming voice input is enabled.

Step 2: Configure API Keys

The installer prompts you for keys at the end. If you skipped that (or want to change providers later):

notepad %USERPROFILE%\Jarvis-OS-Agent\.env

Here's the minimum config to get started:

# FastBrain — for quick commands and chat
FAST_BRAIN_API_KEY=gsk_your_groq_key_here
FAST_BRAIN_MODEL=llama-3.3-70b-versatile
FAST_BRAIN_ENDPOINT=https://api.groq.com/openai/v1

# Primary Brain — for complex multi-step tasks
PRIMARY_API_KEY=gsk_your_groq_key_here
PRIMARY_BASE_URL=https://api.groq.com/openai/v1
PRIMARY_MODEL=llama-3.3-70b-versatile

# Fallback provider (different provider recommended for resilience)
FALLBACK_API_KEY=your_openrouter_key
FALLBACK_BASE_URL=https://openrouter.ai/api/v1
FALLBACK_MODEL=google/gemini-2.0-flash-001

# Web search
TAVILY_API_KEY=tvly-your-key

# Speech-to-text
DEEPGRAM_API_KEY=your_deepgram_key

💡 Using local models? Point PRIMARY_BASE_URL to http://localhost:11434/v1 for Ollama or http://localhost:1234/v1 for LM Studio. Both URLs must end with /v1 — that's the OpenAI-compatible route.

Save, restart JARVIS, and you're operational.

Step 3: Voice Setup (Optional, But Recommended)

Two wake-word engines ship with JARVIS:

Engine	Accuracy	Setup
Azure Custom Keyword	97%+	~30 minutes (one-time)
Vosk KWS (fallback)	~66%	Auto-downloads on first run

If you don't want to touch Azure, skip this. Vosk works out of the box.

But if you want "Jarvis" to actually fire reliably:

Go to Azure Speech Studio
Create a Custom Keyword project (English US)
Train Basic (~30 min) or Advanced (~48h)
Download the .table file
Save as Data/model/azure/jarvis.table
Restart JARVIS

I built this dual-engine system after weeks of frustration with Vosk false triggers. The DSP conditioner (85Hz High-Pass IIR filter + speech-gated AGC) and 5-gate acoustic verifier (Dual WebRTC VAD, SNR, ZCR, duration gating) cut false triggers by ~90%.

Step 4: Add Superpowers via MCP

This is where things get fun.

MCP (Model Context Protocol) lets JARVIS plug into external tool servers — GitHub, Brave Search, SQLite, Notion, Docker, Puppeteer — without writing code.

Add a server from the CLI (JARVIS hot-reloads within 2 seconds — no restart):

# GitHub tools
jarvis mcp add github npx @modelcontextprotocol/server-github -e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_xxx

# SQLite database queries
jarvis mcp add sqlite npx @modelcontextprotocol/server-sqlite C:/data/mydb.sqlite

# Brave Search
jarvis mcp add brave npx @modelcontextprotocol/server-brave-search -e BRAVE_API_KEY=BSAxxx

Then ask JARVIS: "List my open GitHub issues and summarize them."

The MCP layer is one of my favorite parts of the project — it means I don't have to hardcode every tool. Add a JSON entry, hot-reload, done.

🔗 Browse 18,000+ MCP servers at registry.modelcontextprotocol.io

Step 5: Remote Control via Telegram (Optional)

Want to trigger silent PC commands from your phone?

Message @BotFather on Telegram → /newbot → copy the token
Stop JARVIS (Ctrl+C)
Run:

jarvis bot --activate

Paste the token
Restart JARVIS

Now you can message your bot: "Lock my PC" or "Take a screenshot and send it." Commands run silently in the background — your active desktop session stays untouched.

Troubleshooting the Real Issues

Problem	Fix
`jarvis is not recognized`	Open a new terminal. Or run `python SetupRegistry.py` from the repo root.
`ModuleNotFoundError`	Activate the venv: `.\.venv\Scripts\Activate.ps1`, then `pip install -r requirements.txt`
"Already running" error	Stale lock file. Delete `jarvis.lock` in repo root. Check Task Manager for orphan `python.exe`.
Wake word doesn't work	Check `Data/model/azure/jarvis.table` exists. If not, Vosk should auto-download — check startup logs.
MCP tools not appearing	Run `jarvis mcp test <name>` to see exact error. Validate JSON with `python -c "import json; json.load(open('Data/mcp_servers.json'))"`
Portal won't open	Install dependencies: `pip install flask fastapi uvicorn httpx jinja2`

Full diagnostic tree: docs · Troubleshooting →

What I Learned Building This

A few honest reflections after 14 months of solo development:

1. Constraints are features. The limited hardware forced me to use cloud LLMs for reasoning and local embeddings for memory. The result is an agent that runs on hardware most people already own — not a demo that only works on a developer's workstation.

2. Interruptible agents are hard. Most "autonomous" tools are fire-and-forget. Making the loop re-plan mid-execution — without corrupting state or losing completed steps — took months of iteration. There's no tutorial for this. You just fail 40 times until it works.

3. HITL is not optional. I initially let the agent auto-send emails. Then it sent one to the wrong "Rahul" in my contacts. That's when I added the consent gate that cannot be bypassed — even if the LLM insists.

4. Local embeddings are underrated. Everyone reaches for cloud APIs. BAAI/bge-small-en-v1.5 runs on CPU with zero cost, zero quotas, zero rate limits. For personal agent memory, that's more than enough.

5. Documentation is half the product. I spent almost as long writing the docs as I did building the agent. It's the difference between "cool GitHub project" and "something people actually trust."

Honest Limitations

I'd rather you know what JARVIS doesn't do before installing:

Windows-only. macOS and Linux users are out of luck — for now.
Local LLM inference is slow. A 7B model on CPU runs at ~2 tokens/sec. Use cloud providers unless you're 100% offline.
Single-user only. No team features, no multi-user support.
No auto-updates. You manage updates via git pull.

Full limitations page: docs · Known Limitations →

📚 Resources & Links

Resource	Link
🐙 GitHub Repository	github.com/thekaifansari01/Jarvis-OS-Agent
📖 Full Documentation	jarvis-os-agent.vercel.app/documentation
🌐 Official Website	jarvis-os-agent.vercel.app
🔌 MCP Server Registry	registry.modelcontextprotocol.io
🎙️ Azure Speech Studio	speech.microsoft.com/portal
🤖 Telegram BotFather	t.me/BotFather
⚡ Groq API Keys	console.groq.com/keys
📱 Termux (F-Droid)	f-droid.org/packages/com.termux

Final Thought

I built JARVIS because I wanted an AI that actually did things — not one that just talked about doing them. It's not perfect, but it's mine, it's open source, and it runs on hardware most people already own.

If you install it and it works, star the repo. If it doesn't, open an issue — I read every one. If you build something cool with it, tag me. I'd genuinely love to see it.

⭐ Star JARVIS on GitHub · 📖 Read the Docs

— Kaif Ansari

I just Googled "Kaif Ansari Jarvis", and the search results gave me literal goosebumps. 🤯

Kaif Ansari — Sun, 13 Sep 2026 04:01:35 +0000

I didn't hire an SEO agency. I didn't write clickbait articles. I didn't try to hack any algorithm.

For the last 1.5 years, I was just an 18-year-old BCA student sitting in my room, writing 13,000 lines of Python to build my own Autonomous AI Operating System (J.A.R.V.I.S).

Today, Google automatically indexes my developer profile. It officially recognizes my open-source work, my repositories, and my tech stack (Voice AI, LLM Agents, RAG pipelines).

This taught me the greatest lesson about personal branding as a developer:

The best SEO strategy is just to put your head down, write complex code, solve hard problems, and ship real products. You don't need to chase the internet; if you build something valuable, the internet will find you.

If you want to check out the actual work that got indexed, here are all the official links:
🛠️ Jarvis Source Code: https://github.com/thekaifansari01/Jarvis-OS-Agent
📚 Jarvis Architecture & Docs: https://jarvis-os-agent.vercel.app/documentation
🌐 My Developer Portfolio: https://buildwithkaif.vercel.app
🤝 Let's Connect: https://linkedin.com/in/thekaifansari01

Massive thanks to the open-source community for supporting my work! Back to building. 🚀

(Check the Google search screenshot below 👇)

PersonalBranding #SoftwareEngineering #ArtificialIntelligence #BuildInPublic #Developers #SEO #Python

Building a Secure AI Assistant – From Zero to Production (By a 18-Year-Old Solo Developer)

Kaif Ansari — Fri, 14 Aug 2026 10:55:37 +0000

Building a Secure AI Assistant – From Zero to Production

By Kaif Ansari – 18‑year‑old solo developer, BCA fresher, and builder of J.A.R.V.I.S. and Nexus.

The Problem That Started It All

Every time I built a website that needed an AI assistant, I faced the same nightmare: API key exposure.

I'd embed my Groq or OpenAI API key in JavaScript, deploy the site, and within hours, someone would inspect the source code, steal my key, and run up thousands of dollars in usage. I saw it happen to friends. I saw it happen to startups. And I knew there had to be a better way.

So I built one.

What I Built: J.A.R.V.I.S. & Nexus

🤖 J.A.R.V.I.S. – The OS Agent

J.A.R.V.I.S. is a desktop‑native AI operating system for Windows. It's not a chatbot – it's an autonomous agent that can:

🧠 Edit code without line‑drift – exact replace_block diffs, no fragile line numbers.
📱 Control your Android phone via ADB – lock/unlock, send SMS, open apps.
📨 Read your Gmail and Calendar – but always asks for permission before acting (HITL).
🔌 Use multiple LLMs – Groq, Gemini, Regolo, OpenRouter, or local models (Ollama).

🔒 Nexus – The Secure AI Proxy

Nexus is a zero‑trust AI proxy platform that keeps your API keys safe. It works like this:

You store your Groq API key in the Nexus vault – it's encrypted with AES‑256.
You generate a domain‑restricted Nexus key – this is what you embed in your frontend.
The widget sends requests to the Nexus proxy, which verifies the domain origin.
Your Groq key is decrypted server‑side and used only for that request – never exposed to the browser.

The Tech Stack

Layer	Technologies
Frontend	HTML5, Tailwind CSS, Vanilla JS, Phosphor Icons
Backend	Python 3.10+, FastAPI, Vercel Serverless
AI/LLM	Groq LPU, Google Gemini, Regolo, OpenRouter
Database	Firebase (Auth + Firestore), Upstash Redis
Memory	ChromaDB (LTM), Pinecone (RAG)
Mobile	ADB over Tailscale
Deployment	Vercel, GitHub Pages

How I Solved the Security Problem

Step 1: AES‑256 Encryption

Your Groq API key is encrypted before it ever touches the database. The encryption key is managed by Firebase – even we can't decrypt it without your authorization.

Step 2: Domain Whitelisting

Each Nexus key is restricted to a list of domains you authorize. If someone steals your Nexus key, it's useless without a matching whitelisted domain.

Step 3: Server‑Side Proxy

The Groq key is never sent to the browser. The widget sends a Nexus key to our proxy, which validates the origin, decrypts the Groq key, and forwards the request. The response goes back the same way.

This means your key stays safe, encrypted, and never exposed.

Code Snippet: Embedding Nexus in Your Website

<!-- 1. Configure -->
<script>
window.NexusConfig = {
  apiKey: 'YOUR_NEXUS_API_KEY',
  model: 'meta-llama/llama-4-scout-17b-16e-instruct',
  botName: 'Nexus AI',
  greeting: '👋 Hello! How can I assist you today?'
};
</script>

<!-- 2. Load the widget -->
<script defer src="https://cdn.jsdelivr.net/npm/nexus-web-assistant@3.0.0/dist/nexus-assistant.min.js"></script>

That's it. Your website now has a secure, context‑aware AI assistant.

Framework Integrations

Nexus works with every major framework:

⚛️ React – Full guide
▲ Next.js – SSR/SSG compatible
🟢 Vue – Drop‑in script support
🔴 Angular – Works out of the box
🚀 Astro – Zero config
🔷 WordPress – Plugin available

Real Results

Since launching Nexus, I've seen:

400+ developers using the free tier
1,000+ requests processed daily
Zero security breaches – no exposed keys
35% higher conversion rates for sites using AI‑first support

Try It Yourself

Live Demo: trynexus.site/demo
Dashboard: trynexus.site/login
GitHub: NexusWeb
My Portfolio: buildwithkaif.vercel.app

What I Learned (And What You Should Know)

Security must be built in, not bolted on. If you're handling API keys, encrypt them from day one.
Open source is a superpower. When I open‑sourced J.A.R.V.I.S., I got contributions, feedback, and recognition I never expected.
Age is just a number. I'm 18, a BCA fresher, and I built this solo. If I can do it, so can you.
Build in public. Share your progress. It opens doors you can't imagine.

Connect With Me

I love connecting with fellow builders. If you're working on AI agents, LLM apps, or open‑source projects, reach out!

🐙 GitHub: thekaifansari01
🔗 LinkedIn: thekaifansari01
🐦 X (Twitter): thekaifansari01
📧 Email: kaif.ansari.global@gmail.com
🌐 Portfolio: buildwithkaif.vercel.app

⭐ If You Found This Helpful

Star the J.A.R.V.I.S. repo
Star the Nexus repo
Share this post with your network
Follow me for more AI and open‑source content

Built with ❤️ by Kaif Ansari – 18 years old, BCA fresher, and building the AI assistant I always wanted.

I built an autonomous AI OS at 18 — with zero CS background.

Kaif Ansari — Tue, 04 Aug 2026 12:38:18 +0000

Self-taught BCA 1st-year building autonomous OS-level AI agents. Commerce grad, zero CS 2 yrs ago. Built J.A.R.V.I.S. - AI that controls PC, uses tools, remembers. No shortcuts. Just 202 iterations.

What is J.A.R.V.I.S.?

It's not a ChatGPT wrapper. It's a desktop-native AI Operating System that:

🧠 Thinks — Routes simple queries to Groq LPU (<1.5 sec) and complex tasks to reasoning models (Regolo/Gemini/OpenRouter)

🔧 Uses Tools — Opens apps, changes volume, sends emails, WhatsApp messages, edits code

📚 Remembers — ChromaDB long-term memory with daily summarization. Remembers conversations from months ago.

💻 Edits Code Without Line-Drift — Uses exact replace_block diffs instead of fragile line numbers

🛡️ Asks Before Acting — Human-in-the-Loop safety. Never modifies critical data without permission

🔄 Works with Any LLM — Regolo, Gemini, OpenRouter, or local models (Ollama/LM Studio)

Tech Stack: Python, PyQt5, ZMQ, ChromaDB, Groq, Deepgram, Node.js (Baileys)

Why I built it:
I believe AI should DO things — not just chat. I started with zero coding knowledge 2 years ago. No bootcamps. Just curiosity, coffee, and 202 iterations.

The first version was a mess. The latest version is an OS-level agent that controls my PC without me touching a keyboard.

If you're building AI agents or love open-source, let's connect.

🔗 GitHub: https://github.com/thekaifansari01/jarvis-by-kaif-ansari

⭐ If this inspired you, drop a star — it means a lot to a solo developer.