HB Harsh Bhanushali

Harsh Bhanushali.

AI Systems & Autonomous Agents Engineer building stateful agent workflows, RAG systems, and tool-execution pipelines — architecture first, inference second.

$AI_AGENT_ENGINE:~80% of queries routed with 0 LLM calls
STATUS
Open to opportunities
FOCUS
RAG pipelines, multi-agent workflows, MCP
ROLE
AI Engineer
SPECIALTY
Agents · RAG · Tooling
FLAGSHIP
Waypoint
EXPERIENCE
9 mo. full-stack production
SYSTEMS
7+ shipped / built
BACKEND
Python · FastAPI · SQL
WORK MODEL
Remote-friendly · open to relocate
CONTACT
STATE → ROUTE → EXECUTE → VALIDATE → OBSERVE
QUERY CACHE HIT PATTERN RAG LLM VALIDATE RESPOND ~80% ZERO-LLM
FIG. 01, QUERY ROUTING, AI AGENT ENGINE SCALE N.T.S.
01

About

DISCIPLINE
SYSTEMS DESIGN

MATERIAL
PYTHON

METHOD
PLAN, THEN BUILD

I don't start AI projects by choosing an LLM framework. I start by defining state, execution boundaries, deterministic paths, failure modes, and evaluation. Then I decide where an LLM actually belongs.

I spent 9 months as a full-stack developer at Symbiosis Systems, shipping 3 enterprise apps with ASP.NET and SQL Server. That experience shaped how I think about persistence, APIs, validation, and software that has to survive real usage.

Now I apply that discipline to multi-agent systems, RAG pipelines, tool execution, and cost-aware LLM workflows in Python — using frameworks as implementation tools, not as architecture.

02

Systems

A small portfolio of systems built around explicit state, bounded execution, deterministic routing, retrieval, validation, persistence, and human control.

$ openWaypoint

SHEET 01, IN PROGRESS

Multi-agent AI trip planner. You describe a trip through a structured form, a graph of LangGraph agents plans transport, lodging, activities, and budget, the system produces a day-by-day itinerary, and you refine it through a chat-based review loop before finalizing.

5 LangGraph agents7 mechanical tool nodesPostgres checkpointingHuman review + replanning
Engineering signal: state is explicit and write-safe; external tools are separated from agent reasoning; failures route through critique instead of disappearing inside a retry loop.
Build note
Why this architecture: Each tool node (flights, trains, hotels, activities) writes to a separate TypedDict key so parallel fan-out via LangGraph's Send API is write-safe. No merge conflicts. The Postgres checkpointer survives browser refresh and server restart. The human-review gate was added after early versions produced itineraries with impossible connections, like a red-eye flight followed by a 6am hotel check-in.
CONCIERGE PLANNER FLIGHTS TRAINS HOTELS ACTIVITIES BUDGET ITINERARY HUMAN REVIEW FINALIZE CRITIC
Spec Detail
Agents Concierge to Planner to Budget to Itinerary to Critic. 5 LangGraph agents with human-in-the-loop review
Tools 7 mechanical tool nodes: flights, trains, buses, cars, hotels, activities, weather. Staged dummy to free API to MCP
State TypedDict TripState, separate keys per tool result for write-safe parallel fan-out. Postgres checkpointer survives refresh and restart
Stack Python, LangGraph, FastAPI, Postgres, SQLAlchemy, Pydantic, Groq, Tavily
github.com/harshbhanushali26/waypoint
03

Featured systems

$ openhArILIVE

SHEET 02, DEPLOYED

RAG document intelligence. Upload PDFs or CSVs, ask questions, get cited answers. Rebuilt from a single-store ChromaDB prototype into a hybrid-search, multi-user system.

hybrid vector + full-textmulti-user scoped retrievalcited answersDuckDB SQL isolation
Engineering signal: the architecture changed in response to real failure modes , shared retrieval scope, exact-match misses, and unsafe CSV execution.
Live demo sleeps after 12 hours of inactivity (Streamlit Cloud). First load may take 30 to 60 seconds to wake up.
Build note
Why the migration: The ChromaDB prototype struggled with multi-user document isolation. Every user queried the same collection. I migrated to Supabase + pgvector for per-user scoping via Row Level Security. The hybrid retrieval (vector + full-text) was added after pure semantic search kept missing exact keyword matches in legal and financial documents. DuckDB replaced pandas.exec() after I realized untrusted CSV queries could execute arbitrary Python.
USER QUERY PGVECTOR SIMILARITY TSVECTOR FULL-TEXT RPC MERGE DUCKDB ENGINE CITED ANSWER
Spec Detail
Retrieval Hybrid: pgvector similarity + tsvector full-text via a custom Supabase RPC
CSV queries DuckDB SQL engine replacing pandas.exec() for safe multi-CSV queries
Users Supabase Auth, per-user chat persistence, citation UI with telemetry feedback
Live demo harichat.streamlit.app (sleeps after 12h inactivity)
Stack Python, Streamlit, Supabase, pgvector, DuckDB, Groq, LangChain, SentenceTransformer
github.com/harshbhanushali26/hArI

$ openAI Agent Engine

SHEET 03, SHIPPED

Autonomous agent engine. A 4-layer pipeline routes ~80% of queries with 0 LLM calls and keeps measured per-session cost around ~$0.0005.

~80% zero-LLM routes~$0.0005 / session~30ms retrieval benchmarkReplanning on failure
Five sequential agents handle planning, validation, execution, replanning on failure, and response.

Engineering signal: deterministic routing is treated as a first-class execution path, with LLM calls reserved for cases that actually need inference.
Build note
Why this design: I built this after watching API costs scale linearly on a previous project. The cache layer came first. The pattern router came after I noticed about 40% of remaining queries were deterministic (greetings, status checks, timezone conversions). The daily quota enforcement was a hard lesson. A runaway overnight job burned through an entire API quota before morning. The Replanner agent was added when the Executor started failing silently on edge cases instead of retrying with a different approach.
PLANNER VALIDATOR EXECUTOR REPLANNER RESPONDER CHROMADB + SENTENCE- TRANSFORMER, ~30ms
Spec Detail
Retrieval layer ChromaDB + SentenceTransformer RAG, ~30ms latency (measured on 200-query benchmark set)
Cost control Token tracking and daily quota enforcement
Pipeline Planner to Validator to Executor to Replanner (on failure) to Responder. Auto-retry with replanning
Traceability Every decision logged at session level for full audit trail
Stack Python, LangChain, ChromaDB, Gemini, FastAPI, Pydantic
github.com/harshbhanushali26/ai-agent-engine

$ openFinOS

SHEET 04, SHIPPED

Full-stack AI finance platform. A dashboard for passive logging plus a conversational agent for active querying, both writing to the same SQLite store. Third generation of the system.

Build note
Why three generations: The first version stored everything in JSON files and had no query layer. The second added SQLite but every query hit the LLM, which was slow and expensive. This version introduces pattern matching for ~60% of queries (balance checks, category sums, monthly averages) so they resolve with 0 LLM calls. Complex queries stream via Groq with Server-Sent Events. The financial health score was the hardest part. It took four iterations to weight the factors in a way that matched how people actually think about their money.
Spec Detail
Query routing ~60% of queries answered by pattern matching, 0 LLM calls. Complex queries stream via Groq + SSE
Features Financial health scoring, spending forecasts, budget threshold alerts
Auth bcrypt-hardened auth with session tokens and CLI-based recovery
Stack Python, FastAPI, SQLModel, Groq, SSE
github.com/harshbhanushali26/finos

$ openResearch Pipeline

SHEET 05, SHIPPED

6-agent supervisor-driven CLI pipeline. Search, scrape, summarize, critique, synthesize. Complexity-based model routing with Groq and Gemini fallback. Covers 30 to 50 sources across 5 to 9 targeted questions per run.

Spec Detail
Agents Supervisor to Search to Scraper to Summarizer to Critic to Synthesizer
Model routing Groq (llama-3.3-70b) primary, Gemini (gemini-2.0-flash) fallback
Search DuckDuckGo search plus web scraping per query. Auto-detects research gaps mid-run and re-searches
Stack Python, Groq API, Gemini API, DuckDuckGo API
github.com/harshbhanushali26/research-pipeline

$ openNextSteps

SHEET 06, SHIPPED

Automated resume-to-JD gap analyzer. Full skill mapping and personalized roadmap in under 5 to 8 minutes. Clean parse, analyze, output pipeline.

Spec Detail
Parsing Extracts unstructured resume data, evaluates against a raw JD or a job-post URL
Mapping Correlates identified skill gaps to step-by-step learning modules
Pipeline Parse to analyze to output. No hardcoded resume or JD assumptions, works on any format
Stack Python, FastAPI, Groq API, Gemini, Tavily, Pydantic, REST API
github.com/harshbhanushali26/NextSteps
04

Supporting systems

Sheet Function Stack
DevMind, MCP Server Local MCP server with 6 tools. File read/write, Python execution, JSON utilities. HITL confirmation on all write and run actions. Fixed a subprocess stdin isolation bug that silently hangs most naive MCP implementations. Python, MCP SDK, tiktoken
LangGraph Parallel SQL Runner Multi-question parallel SQL execution via LangGraph's Send API, with an inline human review gate before any query fires. LangGraph, Groq, SQLite
05

Capabilities & stack

Tools and frameworks are grouped by the engineering capability they support — orchestration, retrieval, backend systems, reliability, and interfaces.

Orchestration & reasoning

  • RAG, LLM orchestration, tool-callingcore
  • Groq APILLM layer
  • Gemini APILLM layer
  • LangGraphagent graphs
  • MCPtool servers
  • Cost-aware AI designspecialty

Retrieval & data

  • Supabasepgvector / auth
  • DuckDBin-memory SQL
  • ChromaDBembedding store
  • SentenceTransformerembeddings
  • SQLitelocal persistence

Backend & APIs

  • Pythonintermediate+
  • SQLproficient
  • JavaScriptfamiliar
  • FastAPIbackend APIs
  • ASP.NET (C#)enterprise

Delivery & interfaces

  • StreamlitAI UIs
  • Rich CLIterminal UX
  • Git / GitHubversion control
  • uvpackaging
  • Dockerlearning
06

Contact

OPEN FOR OPPORTUNITIES

AI engineer with 9 months of full-stack production experience and a portfolio of agentic, RAG, and tool-execution systems. Open to AI Engineer and Python Developer roles, especially at teams building real AI products.

LOOKING FOR AI Engineer, Python Developer
AVAILABILITY Open to AI Engineer roles at AI-first startups — Mumbai, Pune, Bangalore, Hyderabad, or remote.