DEV Community: DHRUVA WANI

Beyond the Chatbot: A First Look at the Gemini Agent Development Kit (ADK)

DHRUVA WANI — Wed, 29 Apr 2026 07:53:00 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Google Cloud NEXT ‘26 has made one thing abundantly clear: we are officially shifting from the "Chatbot Era" to the "Agentic Era."

When building complex applications—especially those integrating multi-modal AI or vision agents with sleek user interfaces—the biggest bottleneck has always been orchestration. We've been missing a standardized way to bridge the gap between AI generating text and AI actually doing things. The newly announced Gemini Agent Development Kit (ADK) looks to be exactly that bridge.

Here is my first look at the ADK, how it works, and why it is about to change how we architect cloud infrastructure.

💡 What is the Gemini ADK?
At its core, the ADK is an open-source framework designed to help developers build autonomous agents. Instead of just prompting an LLM to generate a script, you can empower an agent to update a database, trigger a CI/CD workflow, or interact with a legacy API autonomously.

🛠 Getting Started: The Workflow

The new kit formalizes the agent creation process into a clean, developer-friendly workflow. If you're used to spinning up backend logic in Python or deploying full-stack apps, the orchestration syntax will feel right at home.

💻 Click here to see the initialization command
Getting started is as simple as pulling the open-source package:


bash
pip install google-adk

The development lifecycle breaks down into three core phases:

Define the Goal: You start by defining a "Mission" for your agent. What is its ultimate objective?

Tool Wiring: Next, you connect the agent to the Agentic Data Cloud, providing it with the specific APIs, databases, and permissions it needs to complete its mission.

Deployment: You package the agent into a container and push it to production.

Once packaged, the deployment flexibility is fantastic. You can deploy it to the new Vertex AI Agent Engine, run it on Custom Infrastructure, or push it directly to Cloud Run. Deploying to Cloud Run feels like an incredibly natural extension for anyone who already relies on it for hosting fast, scalable React or Next.js web apps.

💻 The Developer Experience: Testing Locally
What really stood out to me is how native the local development experience feels. The ADK sets you up with a clean, standard Python file structure (agent.py, .env).

Once you set up your virtual environment, you can run the adk web command. Under the hood, this spins up a local Uvicorn server on port 8000, bringing up a built-in chat interface for immediate testing. If you are accustomed to building modern Python web backends, this setup loop is going to feel incredibly seamless.

(👇 INSERT SCREENSHOT 4 HERE: "ADK file structure and local testing interface")

In the example above, you can see the true power of tool wiring. The agent isn't just guessing; it uses a custom get_vm_issue_details_from_logs python function to actively query Google Cloud Logging, parse the specific compute.instances.stop audit log, and return exactly who (or what API call) spun down the VM. It turns your IDE into a functional command center.

🔒 Agent Identity: Security First
If you are going to let an AI loose in your cloud environment, observability is paramount. One of the standout features of the ADK isn't just what the agents can do, but how they are tracked.

Agents in the ADK are assigned their own traceable identities. If an agent tries to modify a production database or interact with a sensitive storage bucket, the system allows you to trace exactly which agent executed the action and audit the reasoning loop that led to that decision.

🧠 The Evolution of Context
We've been steadily moving along an evolutionary track. We started with basic prompt-and-response LLMs, moved to Retrieval-Augmented Generation (RAG) to ground models in fact, and then began adding basic tools.

Now, as highlighted in the keynote, we are entering the realm of complex reasoning loops and multi-agent systems.

🤔 The Critique: Can it handle the latency?
Google is clearly providing the infrastructure to treat AI as an autonomous worker rather than just an assistant. The shift from Vertex AI Search to Agent Studio suggests that every developer is about to become an "orchestrator" of specialized agents.

However, latency remains a massive question mark.

Running a multi-agent system that needs to "think," query a Cross-Cloud Lakehouse on AWS, and then execute an action back on GCP introduces significant round-trip delays. While Google's hardware is top-tier, testing the new TPU 8i inference speeds will be the real trial by fire to see if it can handle these multi-step reasoning loops in real-time without timing out or creating sluggish user experiences.

🚀 Wrapping Up
"Generative AI" is rapidly just becoming standard "Cloud Computing."

If you aren't building agents yet, the google-adk seems like the best, most structured place to start. It takes the abstract concept of "AI agents" and grounds it in the familiar territory of containers, cloud deployments, and standard libraries.

What NEXT '26 announcement are you most excited to build with? Let's discuss in the comments! 👇

From Webcam to Wellness: Building a Real-Time AI Assistant for Students

DHRUVA WANI — Sun, 01 Mar 2026 06:59:07 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

This project is built for my college community.
In my college, students spend 8–12 hours daily in front of screens — coding, studying, preparing for placements, and meeting deadlines.
Over time, this leads to:

Chronic poor posture
Fatigue
Stress-related breathing patterns
Reduced physical awareness The problem? Most students don’t realize it until discomfort becomes pain.

I wanted to build something proactive — a system that checks in before the damage happens.

What I Built

I built a Real-Time AI Medical Wellness Assistant that transforms a simple video call into a quick wellness check.

In just 8–10 seconds, the assistant:

Analyzes posture (slouching, shoulder imbalance, head tilt)
Estimates breathing rate using chest movement
Detects visible fatigue indicators
Provides empathetic verbal feedback
Generates a structured PDF wellness report

It is not a medical diagnostic tool — it is a preventive awareness system designed to help students self-correct early.

The goal is simple:
Make wellness accessible, instant, and frictionless.

Demo

Code

dhruvawani17 / video-ai

AI medical Wellness Assistnant 🩺

Wellness Assistant is a real-time, AI-powered Medical Wellness Video Assistant. It provides empathetic, non-diagnostic wellness insights by analyzing a user's physical, respiratory, and emotional markers through live video feed using multimodal AI models.

Built with FastAPI, vision-agents, and WebSockets, VitalsAI acts as a proactive wellness companion, capable of observing posture, estimating breathing patterns, and providing instant, conversational voice feedback.

✨ Features

Real-Time Video Analysis: Uses WebRTC and WebSockets to process live camera feeds.
Posture & Kinematics Assessment: Leverages YOLOv11 (yolo11n-pose.pt) to detect spinal alignment, shoulder symmetry, and physical strain.
Multimodal AI Companion:
- Vision: Google Gemini & Ultralytics for visual reasoning and pose estimation.
- Speech-to-Text: Deepgram for real-time transcription.
- Text-to-Speech: ElevenLabs for a calm, clinical, and friendly voice assistant.
Live Dashboard: Real-time insights displayed in a unified HTML/JS dashboard.
Session Reports: Automatically generates a downloadable PDF summary of the wellness session.

…

View on GitHub

The code includes:

Real-time video orchestration
Pose estimation pipeline
Multimodal AI reasoning logic
Speech-to-text and text-to-speech integration
PDF report generation

How I Built It

This project is powered by a real-time multimodal AI architecture.

Core stack:

Vision Agents SDK (agent orchestration layer)
GetStream (WebRTC video communication)
YOLO Pose Estimation (for skeletal keypoints)
Gemini Multimodal LLM (reasoning over visual + text data)
Deepgram (speech-to-text)
ElevenLabs (text-to-speech)
FastAPI (backend server)
React (frontend interface)
Vision Agents handled the event-driven coordination between video, audio, pose extraction, and AI reasoning — allowing me to focus on designing the wellness intelligence layer instead of managing low-level streaming and inference pipelines.

If a simple 10-second check-in can improve a student’s posture, focus, or stress awareness — it’s worth building.
Technology should reduce friction, not add to it.
This is my step toward making AI truly helpful.

MedGuard: Secure Clinical Intelligence

DHRUVA WANI — Sun, 15 Feb 2026 08:04:04 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built MedGuard, a secure clinical intelligence platform that bridges the gap between patient privacy and the power of modern AI.

In the medical field, seconds matter, but so does privacy. Doctors are often stuck between outdated software and powerful AI tools they can't legally use due to HIPAA and GDPR regulations. I wanted to solve this paradox: How can we give doctors access to state-of-the-art LLMs in real-time without ever exposing patient data?

MedGuard is the answer. It is a "Zero-Trust" AI middleware that acts as a firewall for clinical data.

Here is how I architected the solution:

The Privacy Firewall: I built a hybrid sanitization engine using Microsoft Presidio and custom Regex patterns. This layer automatically strips names, MRNs, and dates from PDF reports and scanned notes before they leave the hospital's local environment.

The Speed of Cerebras: To make this viable for emergency rooms, I couldn't afford slow inference. I integrated the Cerebras Inference Cloud (Llama-3.3-70b), which allows MedGuard to analyze complex medical histories and generate triage recommendations in milliseconds, not seconds.

Governance via Archestra: I didn't want a "hallucinating" AI. I used Archestra as my central orchestrator to manage BioMCP (Bio-Medical Control Protocol). Archestra ensures that every AI response is grounded in verified medical protocols (like OpenFDA and AHA guidelines) and monitors the system for data exfiltration attempts and token costs.

What it means to me:
Building MedGuard wasn't just about connecting APIs; it was about proving that we don't have to compromise on security to innovate in healthcare. By combining the raw speed of Cerebras with the governance of Archestra, I’ve created a prototype that demonstrates how AI can be safely deployed in sensitive industries today.

Demo

https://huggingface.co/spaces/dhruvawani17/medguardpro
https://youtu.be/9EX1pynXZKc

My Experience with GitHub Copilot CLI

Using GitHub Copilot CLI transformed my terminal from a simple command executor into an intelligent pair programmer. Instead of constantly context-switching between my code editor and browser documentation, I could stay in the flow and resolve complex infrastructure challenges directly in the command line.

Key ways it impacted my development:

Taming the Regex Beast: Writing robust Regular Expressions for PII redaction is notoriously difficult and error-prone. I used Copilot CLI to generate precise patterns for catching medical record numbers, varying date formats (e.g., "12/05/1984" vs "Feb 14, 2026"), and email addresses. A simple query like ?? "regex python to match medical record numbers and dates" gave me a solid foundation that I could immediately integrate into my redact_pii function.

Streamlining Docker Deployment: Deploying a Python app with system-level dependencies like Tesseract and Poppler is tricky. When my build failed due to missing Linux libraries (libgl1), Copilot CLI was invaluable. I could ask ?? "how to install tesseract and poppler in python slim docker image" and it suggested the correct apt-get commands and the switch to python:3.9-slim-bookworm, saving me hours of debugging "dependency hell."

Rapid Prototyping: For the Streamlit UI, Copilot CLI helped me scaffold the layout commands quickly. I used it to remember the syntax for complex Streamlit widgets like st.data_editor and column layouts without needing to dig through the docs.

Impact:
Copilot CLI didn't just write code; it acted as a DevOps engineer and a Regex specialist. It significantly reduced my debugging time, allowing me to focus on the core logic of MedGuard—security and clinical accuracy—rather than getting bogged down in syntax and configuration errors.

The Agentic Developer: Orchestrating My 2026 Portfolio with Google Antigravity & Gemini 3

DHRUVA WANI — Mon, 26 Jan 2026 18:52:30 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hi! I'm a developer based in Mumbai with a deep passion for AI. Lately, I've been exploring the intersection of web development and Artificial Intelligence. I love trying new AI tools to accelerate my workflow and complete tasks at a faster pace.

I am the author of "The Secrets To Master Your Mind", which I published at the age of 14. Currently, I am enrolled as a student at K.J. Somaiya Institute of Technology.

Portfolio

Experience it fully here

How I Built It

🛠️ The Tech Stack
I wanted my portfolio to be more than just a static page—I wanted it to be an immersive, "liquid" experience. To achieve this, I used a modern, performance-focused stack, orchestrated entirely by Google Antigravity:

Frontend Core: React 19 (via Vite 7) for ultra-fast HMR and build times.

Styling: Tailwind CSS 4 & PostCSS for rapid UI development.

Infrastructure: Docker (Multi-stage build) & Nginx.

Hosting: Google Cloud Run (Serverless container deployment).

🎨 Immersive Design & Animations
To create a "premium" feel, I layered several animation libraries:

Framer Motion: Used for complex component animations and scroll-triggered layout reveals.

GSAP: Powered high-performance tweens and timelines.

Locomotive Scroll: Enabled smooth, inertia-based scrolling to give the site weight and momentum.

WebGL & Shaders: I implemented a custom fluid simulation (SplashCursor.jsx) and particle effects (@tsparticles/react) to create a background that reacts to user interaction.

☁️ Powered by Google Cloud & AI
This project relies heavily on the Google ecosystem for both development and deployment:

Google Cloud Run: I containerized the application using Docker. The Dockerfile uses a multi-stage build (Node 18 for building → Nginx Alpine for serving) to keep the image lightweight. Deploying to Cloud Run was seamless, allowing me to scale to zero when not in use (keeping costs low) while maintaining high availability.

Gemini & AI Assistance: As a Google Student Ambassador, I leverage Google's tools daily. For this project, I used Gemini 3 Pro (via Google Antigravity) to build the entire website from scratch. I generated the UI elements, animations, and styling simply by providing prompts to the Antigravity agents.

What I'm Most Proud Of

I am most proud of finally breaking my cycle of procrastination. I had always put off building my portfolio, but this challenge proved to be the perfect platform to get started. With the help of Google AI tools, I finally completed it.

The animations generated by Antigravity were outstanding and went far beyond my imagination.