DEV Community: Neha Prasad

I’m Building a Visual AI Agent Builder - Because I’m Tired of Debugging Invisible State Machines

Neha Prasad — Tue, 02 Jun 2026 08:20:16 +0000

Every developer I know who builds AI agents has the same ritual: they stare at LangGraph code, draw mental maps, and pray the agent doesn’t silently freeze mid‑loop. I’ve been that person more times than I can count—including once when I tracked a streaming freeze in Mastra down to a missing synthetic tool‑call chunk.

The problem isn’t that we don’t know how to write agent logic. It’s that we have no simple, visual way to see the agent before it runs.

So I’m building Agent Blueprint.

What is it?
A drag‑and‑drop editor where you connect nodes like LLM Call, Tool Execution, Condition, and Human Approval — and export a working LangGraph Python script with one click.

Why now?
LangGraph usage is exploding, but the developer experience is still raw. We deserve a visual canvas that feels as natural as ComfyUI does for image workflows. I’ve merged 150+ PRs in the frameworks that run modern agents (Mastra, LlamaIndex, LiteLLM), so I’m building this from the inside out — with real understanding of where agents break.

What’s next?
I’m documenting the whole build in public — raw updates, architecture decisions, and a live demo this week. If you’ve ever lost an evening debugging a state graph, follow along. And if you want to influence what it becomes, drop your biggest agent‑debugging pain in the comments.

https://www.linkedin.com/feed/update/urn:li:activity:7467474353769701377/
https://x.com/nehaaaa_6/status/2061705090357215682

CompliScore a free compliance health check for Indian startup founders.

Neha Prasad — Mon, 01 Jun 2026 07:00:27 +0000

What I Built
CompliScore - a free compliance health check for Indian startup founders.

Type any company name and get a score out of 100, a list of overdue filings (GSTR-3B, MCA annual returns, notices), a penalty estimate, and a plain-English action plan — in under a minute, no login required.

For this challenge, I rebuilt the AI layer around Hermes Agent. Instead of a single LLM prompt, a reasoning agent plans an investigation, calls deterministic compliance tools, and writes a prioritized report — with a collapsible Agent investigation panel so you can see every plan step and tool call.

Compliance is a natural fit for agentic work: a company with overdue GST needs a filing-calendar deep-dive; one with active notices needs triage; a clean profile needs a light touch. One prompt can't adapt to all three. An agent that picks tools based on what it finds produces tighter, grounded reports.

Note: CompliScore uses fictional demo data only — it does not connect to government portals.

Demo
Live app: https://hermes-scout.vercel.app
(Replace with your actual Vercel URL if it's different.)

Try these scans:

Mumbai Chai Co. — high risk (overdue GST, MCA, multiple notices)
Razorpay — clean profile, score 100
When Hermes is enabled, expand Agent investigation under the AI action plan to see the tool-call trace.

Code
Repository: https://github.com/nehaprasad-dev/hermes-scout

File Role
lib/agent/orchestrator.ts
Plan → tool-call → observe loop
lib/agent/tools.ts
Four compliance tools + validating dispatcher
lib/agent/hermes-client.ts
OpenAI-compatible Hermes client
components/agent-trace.tsx
Collapsible trace UI
My Tech Stack
Next.js 16 (App Router) + TypeScript
Tailwind CSS v4 + Framer Motion
Hermes Agent — OpenAI-compatible /chat/completions with function calling
Groq (llama-3.3-70b-versatile) — fallback when Hermes is unavailable
Vitest — 36 automated tests
Vercel — production deploy
How I Used Hermes Agent
Hermes is the primary reasoning engine when enabled. Every scan runs:

computeHealth() → Hermes agent loop → aiSummary + agentTrace
↓ on failure
Groq → static fallback
Planning: The agent decides which tools to call based on the company profile — not a fixed script.

Tool use: Four deterministic tools so scores are never hallucinated:

Tool Purpose
score_company
Score, risk level, pending tasks
estimate_penalty
GST / MCA / notice breakdown
filing_calendar
Statutory deadlines (90-day horizon)
classify_notices
Severity labels for pending notices
Multi-step reasoning: Hermes reads tool results and writes a founder report — summary, biggest risk, prioritized action plan, and filing calendar — in plain English.

Transparency: Each run returns an agentTrace (plan + tool calls) shown in a collapsible UI panel — no secrets or URLs exposed.

Reliability: Three-tier fallback (Hermes → Groq → static) so scans never break, even when the agent endpoint is down.

Hermes fit this project because it's self-hostable, tool-calling native, and runs over a standard OpenAI-compatible API — while CompliScore's scoring engine stays the source of truth in lib/scoring.ts.

Tags: #hermesagent #ai #nextjs #typescript #startup #opensource #showdev

# DEV Submission Build With Hermes Agent

Neha Prasad — Mon, 01 Jun 2026 06:50:47 +0000

Submission Template

Challenge: Build With Hermes Agent

Project: CompliScore AI compliance health checks for Indian startups

Repo/live-demo: https://github.com/nehaprasad-dev/hermes-scout

What I built

CompliScore gives Indian startup founders a compliance score out of 100 in under a minute - overdue GST filings, MCA returns, penalty exposure, and a plain-English action plan.

The upgrade for this challenge: I replaced the one-shot Groq summary with a Hermes Agent reasoning loop that plans an investigation, calls deterministic compliance tools, and writes a prioritized report - with a collapsible agent trace so judges can see the agentic work.

Why an agent loop fits here

Compliance analysis is conditional. A company with overdue GST needs a filing-calendar deep dive; one with active notices needs notice triage; a clean company needs a light touch. A single prompt guesses all of this at once. An agent that calls tools based on what it finds produces tighter, grounded reports.

Hermes Agent integration

Scan → computeHealth (deterministic score)
     → Hermes Agent loop (plan → tool calls → report)
     → agent trace in UI
     ↓ on failure
     Groq one-shot → static fallback

Four tools exposed to Hermes (scores never hallucinated):

Tool	Purpose
`score_company`	Canonical score, risk level, pending tasks
`estimate_penalty`	GST / MCA / notice penalty breakdown
`filing_calendar`	GSTR-3B, GSTR-1, MCA deadlines (90-day horizon)
`classify_notices`	Severity labels for pending government notices

The agent runs over Hermes's OpenAI-compatible /chat/completions API with function calling — self-hostable via vLLM, LM Studio, Ollama, etc.

Transparency: Every successful agent run returns an agentTrace — plan steps, tool names, compact result previews — rendered in a collapsible panel under the AI action plan.

Reliability: Three-tier fallback (Hermes → Groq → static). Scans never break.

Tech stack

Next.js 16 (App Router), TypeScript, Tailwind v4
Hermes Agent (OpenAI-compatible tool-calling loop)
Groq fallback (llama-3.3-70b-versatile)
Vitest — 35 tests covering tools, orchestrator, and fallback paths

Try it

Visit [live demo URL]
Scan Mumbai Chai Co. (high risk — overdue GST, MCA, notices)
Expand Agent investigation to see the tool-call trace (when Hermes is enabled)
Scan Razorpay for a clean profile

How Hermes Agent is at the heart of this project

This is not a thin wrapper around a single prompt. The scan route calls runComplianceAgent(), which:

Sends the structured health profile + tool schemas to Hermes
Runs a bounded loop (plan → tool call → observe → reason)
Records each step in AgentTrace
Returns the final founder-facing report

The deterministic scoring engine (lib/scoring.ts) stays the source of truth — Hermes reasons about structured facts rather than inventing numbers.

Key files:

lib/agent/orchestrator.ts — agent loop
lib/agent/tools.ts — tool definitions + dispatcher
lib/agent/hermes-client.ts — OpenAI-compatible client
components/agent-trace.tsx — trace UI panel

Production setup

On Vercel (recommended — avoids heavy local LLM inference):

GROQ_API_KEY=your_key          # fast, reliable summaries
HERMES_ENABLED=false             # or true + a public Hermes URL (not localhost)
LEAD_WEBHOOK_URL=your_webhook    # optional

Set HERMES_ENABLED=true only when you have a publicly reachable Hermes endpoint. localhost:8000 works for local dev with a running Hermes server; it cannot work on Vercel.

See DEPLOY.md in the repo for full instructions.

What I learned

Tool design matters more than prompt length — keeping tools bound to pre-computed health data prevents score hallucination
Agent transparency (the trace panel) makes agentic work legible to users and judges
Graceful fallback is non-negotiable for production — Hermes → Groq → static means the product never feels broken

Fixing a Frustrating Bug in LiteLLM Guardrails

Neha Prasad — Tue, 26 May 2026 13:21:00 +0000

You set up custom regex patterns in a Content Filter guardrail, save it, then later toggle the mode (mask ↔ block) or make a small edit - and suddenly all your patterns are gone.
Super annoying.

What was happening?
In LiteLLM’s guardrail settings, the patterns and blocked words were only being sent in the update request if they had changed. So if you only toggled the mode or edited something else, the patterns got wiped out on save.

What I fixed
I updated the logic so that patterns and blocked words are always included when updating a guardrail - whether they changed or not.
Now your custom patterns stay safe no matter what you edit.
PR: https://nehacodes.hashnode.dev/fixing-a-frustrating-bug-in-litellm-guardrails

Lesson Learned

In update operations, never assume existing data will stay unless you explicitly send it. It’s safer to always send the full current state for important fields.

Small fixes like this make developer tools much more reliable and less frustrating to use.

I Built a Compliance Health Scanner for Indian Startups in 24 Hours - Here’s What I Learned

Neha Prasad — Tue, 26 May 2026 12:55:41 +0000

I built this in a day. Not because it was easy, but because I wanted to prove something: Indian founders don't need another complicated dashboard. They need someone to tell them, in plain English, what's broken and what to fix first.

Last weekend, I sat down and built CompliScore – a free 60-second compliance health scanner for Indian startups. You type your company name, and it gives you:

A Compliance Score (out of 100)

A list of pending GST & MCA filings

A penalty risk level (Low / Medium / High)

An AI‑generated action plan written in simple language

🔗 Live Demo: compliscore-nu.vercel.app

Why I Built This

I'm Neha, a software engineer from Mumbai. I've been deep in the compliance automation space for months, building DigiNav AI – an autonomous agent that will eventually handle actual GST filings, incorporation, and audits end‑to‑end.

But the big product takes weeks to build. I needed something today that could help founders right now and also serve as a live portfolio piece. So I stripped everything down to the single most useful action: Show me my risks.

I've also contributed 150+ PRs to core AI agent frameworks (Mastra, LlamaIndexTS, LiteLLM, PostHog) – so I understand both the compliance domain and the AI orchestration under the hood.

What I Learned While Building It

Founders don't care about compliance data. They care about consequences. Most tax-tech tools dump a table of due dates. That's useless. What a founder actually wants to know is:

Am I about to get a penalty?

How much will it cost?

What's the ONE thing I should do right now?

I designed the scanner to answer exactly that. The score and risk badge give an instant emotional signal (green = relief, red = danger), and the AI‑written action plan gives a clear next step in 150 words.

2. Speed builds trust.

The scanner uses mock data for now (real GST/MCA integration is in progress), but the UI flow and the AI logic are production‑ready. I built it in <8 hours using Next.js, Tailwind, shadcn/ui, and Groq for the AI summary. When you ship fast and share publicly, people notice. Within 48 hours of launching, I got an inbound message from a VC‑backed founder building in the exact same space.

3. Personal projects are the strongest resume

.
My GitHub account was flagged due to a 2FA loss, and I lost direct access to my old profile (150+ PRs). But this scanner, built in a day and deployed publicly, has done more for my credibility this week than my entire contribution graph did in a year. Recruiters and founders want to see live proof, not just a heatmap.

Tech Stack (for the curious)
Frontend: Next.js 15 (App Router), Tailwind CSS, shadcn/ui, Framer Motion

AI Layer: Groq API (Llama 3.3 70B) – generates the plain‑English action plan

Data Engine: Static mock data with a scoring algorithm that calculates compliance health based on overdue filings, missing returns, and pending notices

Deployment: Vercel (free tier, instant deploys)

What's Next

I'm currently building the full autonomous agent (DigiNav AI) that will connect to actual GSTN, MCA, and DigiLocker APIs and execute real filings. The scanner is the first step – a free tool that demonstrates the UX I want the full product to have.

If you're a founder and want a real, manual compliance health scan for your business, I offer those for ₹5,000 – delivered in 2 hours. DM me here or on Twitter/X / LinkedIn.

If you're building in the tax‑tech or AI agent space, I'd love to connect and compare notes. Drop a comment or reach out directly.

My links:

Portfolio: https://neha-portfoliooo.vercel.app/

GitHub: https://github.com/nehaprasad-dev

Live Scanner: https://compliscore-nu.vercel.app/

I Built a Compliance Health Scanner for Indian Startups in 24 Hours - Here’s What I Learned

Neha Prasad — Tue, 26 May 2026 12:55:41 +0000

Last weekend, I sat down and built CompliScore – a free 60-second compliance health scanner for Indian startups. You type your company name, and it gives you:

A Compliance Score (out of 100)

A list of pending GST & MCA filings

A penalty risk level (Low / Medium / High)

An AI‑generated action plan written in simple language

🔗 Live Demo: compliscore-nu.vercel.app

Why I Built This

I've also contributed 150+ PRs to core AI agent frameworks (Mastra, LlamaIndexTS, LiteLLM, PostHog) – so I understand both the compliance domain and the AI orchestration under the hood.

What I Learned While Building It

Founders don't care about compliance data. They care about consequences. Most tax-tech tools dump a table of due dates. That's useless. What a founder actually wants to know is:

Am I about to get a penalty?

How much will it cost?

What's the ONE thing I should do right now?

2. Speed builds trust.

3. Personal projects are the strongest resume

Tech Stack (for the curious)
Frontend: Next.js 15 (App Router), Tailwind CSS, shadcn/ui, Framer Motion

AI Layer: Groq API (Llama 3.3 70B) – generates the plain‑English action plan

Data Engine: Static mock data with a scoring algorithm that calculates compliance health based on overdue filings, missing returns, and pending notices

Deployment: Vercel (free tier, instant deploys)

What's Next

If you're a founder and want a real, manual compliance health scan for your business, I offer those for ₹5,000 – delivered in 2 hours. DM me here or on Twitter/X / LinkedIn.

If you're building in the tax‑tech or AI agent space, I'd love to connect and compare notes. Drop a comment or reach out directly.

My links:

Portfolio: https://neha-portfoliooo.vercel.app/

GitHub: https://github.com/nehaprasad-dev

Live Scanner: https://compliscore-nu.vercel.app/

How I Added Multi-Turn Image Generation Support to LlamaIndex

Neha Prasad — Thu, 14 May 2026 19:06:59 +0000

The agent could generate an image once, but when you asked it to modify or create variations - it had no idea what image you were talking about. The conversation had no memory of the previous image.

That broke a lot of interesting multi-turn creative workflows.

Context

While contributing to LlamaIndexTS (the TypeScript version of LlamaIndex), I noticed that image generation tools only worked for single-turn interactions. There was no clean way to reference a previously generated image in follow-up messages. This was especially painful when building agents that iterate on visuals - like creating logos, editing images, or generating multiple versions.

The Investigation

I started by reproducing the issue. The tool was calling OpenAI’s image generation API correctly the first time, but the response didn’t preserve any identifier for the generated image. Later messages had no context about which image to modify.

After digging through the tool calling flow, response parsing logic, and how messages were being stored, I found that the image_id returned by OpenAI wasn’t being extracted or passed forward in the conversation history.

The Solution

I added support for image_id across the board:

Added an image_id parameter to image generation tools

Enhanced response parsing to properly extract and store the image_id from OpenAI responses

Updated message options and tool configurations so subsequent requests can reference previous images

Created a working example showing the full multi-turn image generation workflow

The PR got merged smoothly: feat: multi-turn image generation support #2106

Lessons Learned

Streaming + tool calling can get tricky when the API returns important metadata (like image IDs) that isn’t part of the main content. Always check what fields the model actually returns, not just what you expect. Small details in response parsing can unlock much bigger capabilities.

What about me?
I love diving deep into agent frameworks and fixing core interaction loops. If you're building AI agents (especially ones involving images, tools, or complex workflows) and need help shipping fast - feel free to reach out.