DEV Community

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

Posted on

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

Google Cloud NEXT '26 Challenge Submission

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode
mkdir upwork_agent
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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],
)
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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."

ADK agent response screenshot

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.

Top comments (0)