DEV Community: Gaurang Bhatt

EcoSnap — I Built an AI That Reads Waste Photos and Tells You Exactly What to Do 🌍

Gaurang Bhatt — Sun, 31 May 2026 16:55:32 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

EcoSnap is an AI-powered environmental assistant that turns any photo of waste or pollution into instant, actionable intelligence.

You snap a photo. EcoSnap tells you:

What kind of waste it is and how severe the damage is
How much CO₂ impact it creates
How many years it will take to decompose
An emotional story from the waste's own perspective
5 concrete things you can do about it right now
An AI coach you can chat with for more guidance

The core insight behind EcoSnap came from a real observation in Vadodara, Gujarat, India 🇮🇳 — people see environmental problems every day but don't act because they simply don't know what to do. EcoSnap bridges that gap.

Features

🔍 Eco-Detection
Upload any photo — plastic, garbage, polluted water, dead plants — and Google Gemini Vision AI instantly identifies the waste type, damage level (Low / Medium / High / Critical), CO₂ impact in kg, and years to decompose.

📖 Waste Story (The feature I'm most proud of)
Every piece of waste gets an emotional first-person narrative — told from the perspective of the waste itself. This makes the invisible impact visible and human.

"I was once a vibrant part of the river, teeming with life, but now I am choked by the refuse of humanity. My waters, once clear and life-giving, now bear the scars of neglect and indifference..."

⚡ 5-Minute Action Plan
Not just awareness — action. 5 concrete steps tailored to the specific waste detected.

🌱 Eco Score
A 0–100 environmental health score with a visual progress bar.

💬 AI Eco Coach
A conversational AI coach that answers your environmental questions in plain language.

Demo

🔗 GitHub Repository: https://github.com/exedistrict-ux/ecosnap

Screenshots

Detection Tab — Waste analysis with CO₂ impact and Eco Score:

EcoSnap Detection - Mixed solid waste detected near Taj Mahal river, Critical damage, 5000kg CO2, 500 years to decompose, Eco Score 10/100

Story Tab — Emotional narrative from the waste's perspective:

EcoSnap Story - I was once a vibrant part of the river...

Action Tab — 5-Minute Action Plan:

EcoSnap Action Plan - 5 concrete steps to tackle the detected pollution

Coach Tab — AI conversation:

EcoSnap AI Coach - Conversational environmental guidance

The Comeback Story

This project started during the DEV Weekend Challenge for Earth Day 2026. I had the idea, I had the passion — but I ran out of time before I could finish it properly.

Where it was before:

Just a basic photo upload with a broken Gemini API call
No real UI, no tabs, no styled components
The "Waste Story" feature existed only as an idea in my notes
API key was accidentally committed to GitHub (classic mistake 😅)

What I changed, fixed, and added to finish it:

Built the complete 4-tab UI from scratch (Detection, Story, Action, Coach)
Fixed the Gemini Vision API integration with proper base64 encoding
Added the Waste Story feature — the emotional narrative that makes EcoSnap unique
Built the full AI Coach chat with conversation history
Designed a complete green nature theme with custom typography (Syne + DM Sans)
Fixed the GitHub secret scanning violation and properly secured the API key
Wrote a professional README with full documentation

The transformation from broken prototype to working, polished app happened in 3 days — with GitHub Copilot making a huge difference.

My Experience with GitHub Copilot

GitHub Copilot was genuinely essential to finishing EcoSnap. Here is exactly how it helped:

1. Gemini API Integration
The trickiest part was formatting the vision API request correctly — base64 encoding the image, structuring the inline_data object, and handling the response. Copilot suggested the correct structure on the first try, saving me hours of debugging documentation.

2. JSON Response Parsing
Gemini sometimes returns JSON wrapped in markdown backticks. Copilot suggested the clean regex strip pattern:

const clean = text.replace(/```
{% endraw %}
json|
{% raw %}
```/g, "").trim();

3. Chat History Management
Building the conversational AI coach required managing message history arrays correctly across re-renders. Copilot's suggestions for the state management pattern were clean and worked immediately.

4. CSS Animations
The loading spinner, fadeUp animations, and score bar transition — Copilot generated these CSS keyframes faster than I could have written them manually.

5. Error Handling
Copilot consistently suggested try/catch patterns and fallback states that made the app resilient, not just functional.

Without Copilot, this project would have taken a week. With it, I shipped in 3 days — solo, from a small room in Vadodara in 42°C summer heat. 🌡️

Tech Stack

Frontend: React.js 18
AI: Google Gemini 1.5 Flash (Vision + Text)
Coding Assistant: GitHub Copilot
Fonts: Syne + DM Sans (Google Fonts)
Deployment: GitHub

What's Next for EcoSnap

📍 Nearby recycling center locator
🏆 Community leaderboard
🌐 Multi-language support (Gujarati, Hindi, English)
📱 PWA for direct camera access on mobile

Built for Earth 🌍 | Solo builder from Vadodara, Gujarat, India 🇮🇳
Every photo you snap is a step toward a cleaner planet.

Hermes Agent vs. The Cloud: A Developer's Guide to Local AI Agents

Gaurang Bhatt — Sat, 30 May 2026 11:55:24 +0000

This is a submission for the Hermes Agent Challenge: Write About Hermes Agent

If you've been watching the AI agent space, you've probably noticed a frustrating trend: the most capable systems are locked behind APIs you don't control. That's what makes Hermes Agent different. It's an open-source agentic framework designed to run entirely on your own infrastructure.

In this guide, I'll walk you through setting up Hermes Agent locally and connecting it to real tools — no cloud dependencies required.

What is Hermes Agent?

Hermes Agent is an open-source agentic system built for developers who want AI agents capable of:

Planning multi-step tasks autonomously
Using tools (APIs, databases, file systems)
Reasoning across complex, dynamic workflows

Unlike closed-source alternatives, everything runs on your hardware. You own the model, the data, and the execution environment.

Why Run an Agent Locally?

Privacy — Your data never leaves your machine
Cost — No per-token API fees for inference
Control — Fine-tune behavior without vendor lock-in
Customization — Modify the reasoning loop and tool integrations

Setting Up Hermes Agent

Prerequisites

Python 3.10+
GPU with 8GB+ VRAM (or CPU with sufficient RAM)
Git

Step 1: Clone the Repository

bash
git clone https://github.com/hermes-agent/hermes-agent.git
cd hermes-agent

Step 2: Install Dependencies

bash
pip install -r requirements.txt

Step 3: Configure Your Model

Create a config.yaml:

yaml
model:
  backend: "llama-cpp"
  path: "./models/hermes-3-llama-3.1-8b-Q4_K_M.gguf"
  context_length: 8192

agent:
  max_iterations: 10
  temperature: 0.7

Step 4: Define Your First Tool

Create tools/search.py:

Python
import requests

def web_search(query: str) -> str:
    """Search the web for information."""
    response = requests.get(f"https://api.search.example?q={query}")
    return response.json()["results"]

Python
from .search import web_search

TOOLS = {
    "web_search": web_search,
}

Step 5: Run Your First Task

python -m hermes_agent --task "Find the latest news about open-source AI agents"

How It Works: The ReAct Loop

Hermes Agent follows a Reasoning + Acting cycle:

Observation — Receives input or feedback
Thought — Reasons about next steps
Action — Selects and executes a tool
Repeat — Until task completion

This loop enables true multi-step problem solving, not just text generation.

Practical Tool Integrations

File System Operations

def read_file(path: str) -> str:
    with open(path, 'r') as f:
        return f.read()

Database Queries

Python
import sqlite3

def query_database(sql: str) -> list:
    conn = sqlite3.connect('data.db')
    cursor = conn.cursor()
    cursor.execute(sql)
    return cursor.fetchall()

Tips for Better Results

Tip	Why It Helps
Write detailed tool descriptions	The agent uses docstrings to choose tools
Start with narrow tasks	Complex tasks may need custom planning
Use structured output formats	JSON schemas improve parsing
Monitor the reasoning loop	Add logging to see step-by-step thinking

Limitations

Hardware requirements — Local models need significant compute
Tool reliability — The agent depends on tool quality
Planning complexity — Long-horizon tasks may need custom orchestration

Final Thoughts

Hermes Agent represents something important: a capable, open alternative in a space increasingly dominated by closed systems. Whether you're building a research assistant or experimenting with agentic AI, running it locally gives you freedom that API-only solutions can't match.
The project is actively developed, and the community is growing. If you're curious about the future of open AI agents, Hermes Agent is worth your time.

Resources

Hermes Agent GitHub
DEV Hermes Agent Challenge

Have you tried Hermes Agent? Share your setup experience in the comments!

How I Added dbt Cloud to Coral — My Open Source Hackathon Journey

Gaurang Bhatt — Thu, 28 May 2026 09:20:30 +0000

What is Coral?

Coral is an open-source tool that lets you query any API, database,
or file as SQL — no ETL, no warehouse, no glue code.

The Problem I Solved

dbt Cloud is used by thousands of data engineers. But there was no
way to query dbt Cloud jobs, runs, and environments via SQL. I built that.

What I Built

PR #627 — dbt Cloud Community Source

Added 3 tables to Coral:

dbt_cloud.jobs — all jobs with schedules and state
dbt_cloud.runs — run history with status codes
dbt_cloud.environments — deployment environments

The Code

# manifest.yaml (simplified)
name: dbt_cloud
backend: http
tables:
  - name: jobs
  - name: runs  
  - name: environments

Live Demo

-- Query 890 open PRs from Coral repo
SELECT number, title, state 
FROM github.pulls 
WHERE owner='withcoral' AND repo='coral' 
AND state='open' 
LIMIT 1000

Result: 890 rows in ~10 seconds. No ETL. Just SQL.

Status Codes I Learned

dbt Cloud run status codes:

1 = Queued
2 = Starting
3 = Running
10 = Success
20 = Error
30 = Cancelled

Challenges

Pagination — dbt Cloud uses offset pagination, had to implement correctly
Timestamps — ISO8601 format needed special handling in Coral DSL
Virtual columns — filter echo columns needed for debugging

What I Learned

How to write a Coral source manifest (DSL v3)
HTTP backend configuration
Open source contribution workflow — fork, branch, PR, review
Real API pagination patterns

The Result

PR #627 merged into withcoral/coral ✅

Now any Coral user can:

SELECT j.name, r.status, r.started_at
FROM dbt_cloud.runs r
JOIN dbt_cloud.jobs j ON j.id = r.job_id
WHERE r.status = 20  -- Error
ORDER BY r.started_at DESC
LIMIT 20;

Try It Yourself

coral source add --file sources/community/dbt_cloud/manifest.yaml
coral sql "SELECT * FROM dbt_cloud.jobs LIMIT 10"

I Built Multi-Agent Systems Before NEXT '26 — Here's What the New ADK, MCP & A2A Stack Actually Changes

Gaurang Bhatt — Tue, 28 Apr 2026 12:07:27 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

I Built Multi-Agent Systems Before NEXT '26 — Here's What the New ADK, MCP & A2A Stack Actually Changes

I'll be honest: when Google Cloud NEXT '26 started announcing updates to the agent platform, my first reaction wasn't excitement — it was relief.

Over the past few months, I've been systematically building up on the Google Cloud agent ecosystem — starting from the Cloud Technical Series OnBoard Edition (January 2026, hands-on AI Agents), then AI in Action (March 2026, Gemini Enterprise & agentic CX), through Code Vipassana Season 14 ("Building Serverless Data Agents", Outstanding rating), and finally the Gen AI Academy APAC Edition where I built and deployed a live Multi-Agent Productivity Assistant on Cloud Run. I've written real code with ADK, integrated MCP tools, debugged agent routing issues at 11pm, and even submitted a PR to the MCP Toolbox Java SDK to fix a broken run command that was tripping up developers.(https://github.com/exedistrict-ux/mcp-toolbox-sdk-java/pull/1) to fix a broken run command that was tripping up developers.

So when I say the announcements at NEXT '26 — specifically around ADK, MCP becoming universal, and the A2A Protocol — are genuinely meaningful, I'm not speaking as someone who read a blog post. I'm speaking as someone who felt these pain points firsthand.

Let me show you exactly what changed and why it matters.

The Pain I Was Solving (Before NEXT '26)

In my Gen AI Academy project, I built a multi-agent system with a ProductivityCoordinator primary agent that routed requests to three sub-agents: TaskAgent, NotesAgent, and CalendarAgent — all deployed serverlessly on Google Cloud Run.

The architecture worked. But building it was messier than it should have been.

The biggest friction points were:

1. Tool integration required too much manual wiring. Connecting each sub-agent to its data source meant writing custom adapter logic every time. There was no standard interface — you just hoped your patterns were consistent.

2. Agent-to-agent communication was hardcoded. My ProductivityCoordinator knew about TaskAgent, NotesAgent, and CalendarAgent at build time. If I wanted to add a new sub-agent, I had to modify the coordinator's routing logic manually. There was no discovery mechanism.

3. MCP tools existed, but weren't seamlessly integrated. I integrated three MCP tools as sub-agents in my project. It worked, but it required explicit configuration for each one. The dream of "just point your agent at a service and it works" wasn't quite reality yet.

Now look at what NEXT '26 announced.

1. ADK: From Pattern to Platform

When I built my multi-agent system, I was following the ADK pattern — primary agent coordinating sub-agents, tools attached via function definitions, deployed on Cloud Run. It worked, but I was essentially implementing the pattern myself with Flask and Python.

The ADK announced at NEXT '26 formalizes all of this. The AgentRuntime handles what I was doing manually: session management, scaling, retry logic, state persistence across requests.

Here's roughly what my coordinator looked like before:

# My Gen AI Academy project — manual routing
class ProductivityCoordinator:
    def route(self, message: str):
        if "task" in message.lower():
            return self.task_agent.handle(message)
        elif "note" in message.lower():
            return self.notes_agent.handle(message)
        elif "calendar" in message.lower():
            return self.calendar_agent.handle(message)
        elif "dashboard" in message.lower():
            # Multi-step: call all three simultaneously
            return self.aggregate_all(message)

With the new ADK, the AgentRuntime handles the plumbing. You focus on defining skills and tools — not writing routing logic from scratch.

from google.cloud.agents import ADK, Tool

@Tool(name="manage_tasks", description="Add, list, or complete tasks")
def manage_tasks(action: str, task_title: str = None) -> dict:
    # Your task logic here
    return result

agent = ADK.create_agent(
    name="productivity-coordinator",
    model="gemini-2.0-flash",
    tools=[manage_tasks, manage_notes, manage_calendar]
)

This isn't a trivial improvement. The boilerplate I wrote for my Code Vipassana S14 project would shrink dramatically.

2. Universal MCP: The Integration Problem, Solved

This is the announcement that made me stop and re-read twice.

Every Google Cloud service is now MCP-enabled by default.

In Code Vipassana Season 14, one of the sessions I attended was specifically on building secure multiagent systems with Model Armor and MCP Toolbox for Databases. I also attended the session on building a schema-aware agent with BigQuery. In both cases, MCP tools required explicit setup — you had to define the connection, configure credentials, and write the integration.

That's now gone. Here's what the new model looks like:

{
  "protocol": "mcp",
  "tool": "bigquery.query",
  "parameters": {
    "project_id": "my-project",
    "query": "SELECT * FROM productivity.tasks WHERE status = 'pending'"
  }
}

Your agent sends a standard MCP request. The Cloud service handles auth, execution, and returns a standardized response.

I actually found the typo in the MCP Toolbox Java SDK's README while working through one of these integrations — the run command said mvn sprint-boot:run instead of mvn spring-boot:run. A small thing, but the kind of friction that breaks developer flow. I submitted a PR to fix it. The broader point: this tooling was still rough. Universal MCP support is Google acknowledging that and doing something about it.

3. A2A Protocol: The Missing Piece in My Architecture

This is the one that would have changed my Gen AI Academy project the most.

My ProductivityCoordinator was hardcoded. It knew its sub-agents at build time. That's fine for a bounded project, but it doesn't scale. If you want a genuinely modular agent architecture — where new specialists can be added without modifying the orchestrator — you need a discovery mechanism.

The Agent-to-Agent (A2A) Protocol and Agent Registry are exactly that.

# How my Gen AI Academy project COULD have been built
registry = AgentRegistry.connect()

# Coordinator dynamically discovers what's available
available_agents = registry.find_agents(domain="productivity")

# Routes to the right specialist at runtime — not build time
result = await available_agents.route(
    task=user_message,
    context=session_context
)

With A2A, adding a new sub-agent (say, an EmailAgent) doesn't require touching the coordinator at all. It registers itself, announces its capabilities, and the orchestrator discovers it dynamically.

This is what I was manually approximating. Now there's a protocol for it.

Memory Bank: The Problem I Didn't Fully Solve

In my productivity assistant, state was in-memory per session. Tasks, notes, and calendar events persisted within a session but not across them. That was fine for a demo, but in production it's a real limitation.

Memory Bank addresses this directly — agents can store and retrieve context across sessions using semantic similarity:

agent = ADK.create_agent(
    name="productivity-coordinator",
    memory=MemoryBank(
        store="long_term",
        retrieve_strategy="semantic_similarity"
    )
)

A user's task priorities, their preferred working style, their recurring meeting patterns — all of this can now persist. This is the difference between a demo and a product.

What I'm Still Watching

A few honest caveats from someone who has been in the weeds:

Agent Identity and IAM integration is the piece I'm most cautious about. In my Code Vipassana S14 session on secure multiagent systems, we saw how quickly authorization complexity compounds when you have multiple agents accessing different data sources. The Agent Identity feature looks right architecturally — each agent gets its own service account — but I'll want to see how it handles cross-agent delegation in practice before trusting it in a production billing or HR system.

The "serverless" promise depends heavily on cold start behavior. My Cloud Run deployment for the productivity assistant had noticeable cold starts. Agent Runtime inherits Cloud Run's runtime, so the same tradeoffs apply. For latency-sensitive agentic workflows, this matters.

A2A's Agent Registry is only as useful as what's registered in it. The discovery mechanism is elegant, but in a real enterprise environment, you'll need governance around what gets registered and how capabilities are described. That's an organizational challenge as much as a technical one.

The Full Picture

Here's how the stack connects, from my perspective as someone who has built pieces of this manually:

User Request
     │
     ▼
Orchestrator Agent (ADK + AgentRuntime)
     │
     ├── MCP ──► Any Google Cloud Service (BigQuery, Spanner, GCS...)
     │           [No custom adapters. Default on everything.]
     │
     ├── A2A ──► Agent Registry ──► Specialist Agents
     │           [Dynamic discovery. No hardcoded routing.]
     │
     ├── Memory Bank
     │   [Persistent context across sessions.]
     │
     └── Agent Gateway + Agent Identity
         [IAM at the agent level. Centralized policy.]

Six months ago, I was building the middle three layers by hand. ADK gave me the pattern but not the platform. MCP tools existed but weren't universal. Agent-to-agent communication was ad-hoc.

NEXT '26 is Google Cloud saying: we're making this the platform, not just a pattern.

Where to Start

If you want to get hands-on with this stack:

Code Vipassana — The lab series I went through. Season 14 covered serverless data agents end-to-end. Highly recommend the ADK and MCP sessions specifically.
Gen AI Academy APAC Edition — Cohort 1 just wrapped. Watch for the next cohort if you want structured hands-on time with the full stack.
ADK Docs: cloud.google.com/agent-development-kit
A2A Protocol: cloud.google.com/a2a

The NEXT '26 Developer Keynote sessions are available on the DEV homepage — the demos of ADK + MCP + A2A working together are worth watching even if you've read all the docs.

I'm Gaurang Bhatt — Code Vipassana Season 14 Troubleshooter, Gen AI Academy APAC participant. Currently building on Google Cloud and occasionally fixing typos in SDKs at odd hours. What are you building with the new agent stack? Drop it in the comments.

Unnecessary Dark Mode™ — It Just Gets Darker (And That's It)

Gaurang Bhatt — Thu, 09 Apr 2026 04:26:48 +0000

This is a submission for the DEV April Fools Challenge

What I Built

A dark mode toggle that does exactly one thing: make your screen darker. And darker. And darker.

No light mode comeback. No useful UI. No purpose. Just 10 levels of increasing darkness until you can't see anything at all — and a little message at the end congratulating you on achieving absolutely nothing.

Level 0: "Perfectly usable. How boring."
Level 10: "You have reached peak dark mode. Congratulations on nothing."

Demo

🔗 Live Demo on CodePen

Code

<!-- Core concept: a button that makes things worse -->
<button onclick="moreDark()">Make it darker ▾</button>
` ` `

Full source: [CodePen](https://codepen.io/Gaurang-Bhatt-the-scripter/pen/QwKVJzN)

## How I Built It

Pure HTML + CSS + vanilla JavaScript. No frameworks. No libraries. No dependencies — because why add complexity to something this pointless?

- 10 dark levels using CSS classes
- Smooth `transition` animations between levels
- Stars appear as it gets darker (for atmosphere)
- Progress bar that tracks how deep into uselessness you've gone
- Messages that get increasingly philosophical as the screen dies

Total build time: ~1 hour. Time spent questioning my life choices: ongoing.

## Prize Category

**Community Favorite** — because sometimes the internet just wants to watch a screen go dark for no reason.

બસ આ paste કરો અને Publish દબાવો! All the best! 🏆

DEV Community: Gaurang Bhatt

EcoSnap — I Built an AI That Reads Waste Photos and Tells You Exactly What to Do 🌍

What I Built

Features

Demo

Screenshots

The Comeback Story

My Experience with GitHub Copilot

Tech Stack

What's Next for EcoSnap

Hermes Agent vs. The Cloud: A Developer's Guide to Local AI Agents

What is Hermes Agent?

Why Run an Agent Locally?

Setting Up Hermes Agent

Prerequisites

Step 1: Clone the Repository

Step 2: Install Dependencies

Step 3: Configure Your Model

Step 4: Define Your First Tool

Step 5: Run Your First Task

How It Works: The ReAct Loop

Practical Tool Integrations

File System Operations

Tips for Better Results

Limitations

Final Thoughts

Resources

How I Added dbt Cloud to Coral — My Open Source Hackathon Journey

What is Coral?

The Problem I Solved

What I Built

The Code

Live Demo

Status Codes I Learned

Challenges

What I Learned

The Result

Try It Yourself

Links

I Built Multi-Agent Systems Before NEXT '26 — Here's What the New ADK, MCP & A2A Stack Actually Changes

I Built Multi-Agent Systems Before NEXT '26 — Here's What the New ADK, MCP & A2A Stack Actually Changes

The Pain I Was Solving (Before NEXT '26)

1. ADK: From Pattern to Platform

2. Universal MCP: The Integration Problem, Solved

3. A2A Protocol: The Missing Piece in My Architecture

Memory Bank: The Problem I Didn't Fully Solve

What I'm Still Watching

The Full Picture

Where to Start

Unnecessary Dark Mode™ — It Just Gets Darker (And That's It)

What I Built

Demo

Code