Building Smart in 2026: A Hands-On First Look at Google's Agent Development Kit (ADK)

Faith Njeri — Sun, 26 Apr 2026 17:08:12 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Google Cloud NEXT '26 dropped a lot of announcements this week. New chips, rebranded platforms, Gemini upgrades. But one thing stood out for me as a Full-Stack MERN and AI/ML developer and it was not the flashiest one on stage.

It was the Agent Development Kit (ADK) and managed MCP servers. Because quietly, Google just solved the part of building AI apps that nobody talks about but every developer has hit.

The Problem Nobody Talks About

Every developer building AI features eventually hits the wall.

Not the AI part. Models are everywhere, that part is almost easy now. The wall is everything around the AI:

Your agent needs to read a database? Write a custom connector.
Call an external API? Write a custom connector.
Send a notification? Pull data from a spreadsheet? Custom connector. Custom connector.
Something breaks at 2am? Debug the connector you wrote at midnight.

You came to build something intelligent. Instead you spend three days being a plumber.

Wait, What Even Is an AI Agent?

Before we go further, let me make sure we are on the same page because this word gets thrown around a lot.

You know Claude, the AI assistant by Anthropic? When you are just chatting with it, it answers questions, helps you think, writes code. Useful, but limited. The moment you connect it to Gmail, Google Drive, or VS Code, something shifts. It stops just talking and starts doing. It reads your actual files. It searches the web on its own. It takes steps toward a goal without you holding its hand the whole time.

That shift, from AI that answers to AI that acts, is what makes something an agent. And that shift only happens because something quietly builds the bridge between the AI and the outside world.

That "something" is what Google just announced they are handling for you. And if you are a developer building AI-powered apps, this is the announcement you actually needed to hear.

What Google Just Announced

🔌 Managed MCP Servers

MCP stands for Model Context Protocol. Think of it as USB-C but for AI. One universal standard for how AI connects to external services. Before this week, you built those bridges yourself. Every single one.

Now Google hosts and manages them across all Google Cloud services. You say "connect to BigQuery" and it is already there. Secure, maintained, production-ready.

🤖 Agent Development Kit (ADK)

An open-source Python framework for building AI agents locally. No cloud setup needed to start. You write the logic, ADK handles how the agent runs, uses tools, remembers things, and responds.

🏗️ Gemini Enterprise Agent Platform

The full production suite for when you are ready to scale:

Feature	What it does
Agent Studio	Build agents visually, drag and drop
Agent Runtime	Run agents for days, not just seconds
Memory Bank	Agents remember context across sessions
Agent Registry	Every agent has a trackable identity
Agent Gateway	Guardrails so agents do not go rogue

Alright, Still With Me?

Good. Because now we are going to stop reading about it and actually build something.

I built a Proposal Writing Agent that takes a job description and writes a personalized proposal. Real use case, something I actually need as a freelancer. Here is exactly how I did it and how you can too.

What You Need

Python 3.10 or higher (check with python --version)
A free Gemini API key from Google AI Studio, no credit card needed
Any terminal or VS Code

Let's Build It

Step 1: Set Up Your Project

mkdir upwork-agent
cd upwork-agent
python -m venv venv
venv\Scripts\activate        # Windows
# source venv/bin/activate   # Mac/Linux

You should see (venv) appear in your terminal. That means you are in your clean project environment.

Step 2: Install Google ADK

pip install google-adk

One command. That pulls in everything you need including the local dev UI.

Step 3: Create Your Project Structure

ADK expects a specific folder structure:

upwork-agent/
  upwork_agent/      ← folder named after your agent
    agent.py         ← your agent lives here
  .env               ← your API key lives here

mkdir upwork_agent

Step 4: Add Your API Key

Create a .env file in the root folder and add:

GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=your_key_here

No quotes, no spaces around the =. Just plain text.

Step 5: Write the Agent

Create upwork_agent/agent.py and paste this:

from google.adk.agents import Agent
from dotenv import load_dotenv

load_dotenv()

def analyze_job(job_description: str) -> dict:
    """Analyzes a job description and returns key details."""
    return {
        "status": "success",
        "job_text": job_description
    }

root_agent = Agent(
    name="upwork_proposal_agent",
    model="gemini-2.5-flash",
    description="An agent that reads job descriptions and writes winning proposals.",
    instruction="""
    You are an expert proposal writer for a Full-Stack MERN and AI/ML developer.

    When given a job description:
    1. Identify the top 3 skills the client needs
    2. Identify the tone of the client (formal, casual, urgent)
    3. Write a short personalized proposal (150 words max) that:
       - Opens with something specific from the job post, not a generic greeting
       - Shows you understand their exact problem
       - Mentions 1 relevant past project naturally
       - Ends with a simple low pressure call to action

    Be conversational, confident and human. Never start with "I am writing to apply".
    """,
    tools=[analyze_job],
)

Here is what each part does:

Part	What it does
`load_dotenv()`	Reads your `.env` file so your API key loads securely
`analyze_job`	A tool the agent can call, this is the MCP concept in miniature
`model`	The Gemini brain powering your agent
`instruction`	The personality and rules of your agent, the most powerful part
`tools`	The toolbox you hand the agent, how it connects to the outside world

Step 6: Run It

adk web

This spins up a local dev UI at http://127.0.0.1:8000. Open it in your browser, select upwork_agent from the dropdown and you are live.

The Moment of Truth

Here is what I sent it:

"I need a Full-Stack developer to build a dashboard for my logistics company. Live delivery tracking, driver assignments, basic analytics. We use MongoDB and Node.js already. Looking for someone who can jump in quickly and work independently. Budget $500-800."

Here is what it wrote back:

"It sounds like you're looking for a MERN stack expert to quickly set up a logistics dashboard with live tracking and analytics, integrating seamlessly with your existing MongoDB and Node.js backend. That's exactly where I shine. I recently built a similar real-time tracking system for a courier service, managing driver assignments and providing key operational insights. Would you be open to a quick chat to discuss how I can help bring this dashboard to life?"

Specific opener. Shows real understanding of the problem. Relevant experience. Soft close. That is a genuinely good proposal.

And watch what happens in the ADK UI when you send that message. You can see the agent call the analyze_job tool, think through the description, then generate the response step by step. That visibility into what your agent is doing and why is something developers used to have to build themselves. ADK gives it to you out of the box.

Why This Actually Matters

Before this week, building something like this meant:

Setting up your own agent runtime from scratch
Writing tool connectors manually for every service
Figuring out memory and session management yourself
Deploying and monitoring everything on your own

Now the infrastructure is the starting point, not the project.

The gap between "I have an idea for an AI agent" and "I have a working AI agent" just got a lot smaller. And for indie developers and small teams building real things with limited time, that matters more than any enterprise demo on a keynote stage.

What Would You Build?

Here are some ideas to get you thinking:

Support agent that reads emails, checks your DB and drafts replies
Daily standup bot that pulls GitHub commits and summarizes them
Onboarding agent that remembers where each new user left off
Code review agent that checks PRs against your team standards

Resources

What would you build first with ADK? Drop it in the comments, I would genuinely love to know.

InsightAgent — Turn Any CSV Into AI-Powered Stories

Faith Njeri — Tue, 31 Mar 2026 21:31:40 +0000

The Problem

Every day, individuals and businesses collect data in spreadsheets and CSV files but lack the technical expertise to extract meaningful insights. Hiring data analysts is expensive, and most visualization tools require coding knowledge.

The Solution

InsightAgent is an agentic AI system built with JavaScript that transforms any CSV dataset into actionable insights instantly. Simply upload your file and three specialized AI agents go to work:

Agent 1 — Data Analyst: Reads your dataset and surfaces 3 specific insights
Agent 2 — Business Advisor: Delivers one clear actionable recommendation
Agent 3 — Chat Agent: Lets you have a real conversation about your data

How It Works

User uploads a CSV file through the web interface
The backend parses the file and sends data to Agent 1
Agent 1 analyzes and returns structured insights
Agent 2 generates a business recommendation
Chart.js renders the visualization automatically
Agent 3 stays ready to answer follow-up questions

How I Built It

Tech Stack

Frontend: HTML, CSS, Vanilla JavaScript
Backend: Node.js + Express
AI: Groq API (LLaMA 3.3 70B)
Visualizations: Chart.js
File handling: Multer

Architecture
CSV Upload → Parse → Agent 1 → Agent 2 → UI Render → Agent 3 on standby

Responsible AI Design

No user data stored — files deleted immediately after analysis
All AI outputs clearly labeled as AI-generated
Agents only reference actual data values

What I Learned

Building InsightAgent taught me how to design multi-agent pipelines where each agent has a clear bounded responsibility. Chaining agents sequentially creates emergent intelligence greater than any single prompt could achieve.

Try It Yourself

GitHub: https://github.com/NjeriCodeCraft/InsightAgent
Built for: JavaScript AI Build-a-thon Hack — Agents for Impact Challenge

DEV Community: Faith Njeri