Google Launches Agent Development Kit for TypeScript: Build AI Agents With Tools You Already Know

Hello HaWkers, Google has just launched the Agent Development Kit (ADK), an open-source framework that allows building autonomous AI agents using TypeScript and JavaScript. This means you can create intelligent agents with the same tools and practices you already know from web development.

Have you ever thought about creating an agent that automates complex tasks, navigates the web, interacts with APIs, and makes context-based decisions - all with TypeScript? Now it is possible.

What is the Agent Development Kit

ADK is a "code-first" approach to building AI agents. Unlike no-code or low-code tools, ADK gives developers full control over agent behavior.

Code-First Philosophy

Why code-first matters:

Full control over logic and flow
Git versioning like any code
Unit and integration tests
Reuse of existing libraries
Debug with familiar tools

Main Features

What ADK offers:

Multi-step agent orchestration
Integration with external tools
Persistent memory between sessions
Response streaming
Support for multiple AI models
Complete type safety with TypeScript

Getting Started with ADK

Let us see how to create your first agent with ADK:

# Install ADK
npm install @google/adk

# Or with yarn
yarn add @google/adk

Creating a Simple Agent

import { Agent, Tool } from '@google/adk';

// Define a tool the agent can use
const searchTool = new Tool({
  name: 'web_search',
  description: 'Search the web for information',
  parameters: {
    query: {
      type: 'string',
      description: 'The search query',
      required: true,
    },
  },
  execute: async ({ query }) => {
    // Implement actual search here
    const results = await performWebSearch(query);
    return { results };
  },
});

// Create the agent
const agent = new Agent({
  name: 'ResearchAssistant',
  description: 'An agent that helps with research tasks',
  model: 'gemini-pro',
  tools: [searchTool],
  systemPrompt: `
    You are a helpful research assistant.
    Use the web_search tool to find information.
    Always cite your sources.
  `,
});

// Run the agent
const response = await agent.run({
  message: 'What are the latest trends in web development for 2026?',
});

console.log(response.content);

Building Complex Agents

ADK shines when you need agents that execute multi-step tasks:

Code Analysis Agent

import { Agent, Tool, Memory } from '@google/adk';

// Tool to read files
const readFileTool = new Tool({
  name: 'read_file',
  description: 'Read a file from the filesystem',
  parameters: {
    path: { type: 'string', required: true },
  },
  execute: async ({ path }) => {
    const content = await fs.readFile(path, 'utf-8');
    return { content, path };
  },
});

// Tool to analyze code
const analyzeCodeTool = new Tool({
  name: 'analyze_code',
  description: 'Analyze code for issues and improvements',
  parameters: {
    code: { type: 'string', required: true },
    language: { type: 'string', required: true },
  },
  execute: async ({ code, language }) => {
    // Use ESLint, TypeScript compiler, etc.
    const issues = await runStaticAnalysis(code, language);
    return { issues, suggestions: generateSuggestions(issues) };
  },
});

// Tool to write files
const writeFileTool = new Tool({
  name: 'write_file',
  description: 'Write content to a file',
  parameters: {
    path: { type: 'string', required: true },
    content: { type: 'string', required: true },
  },
  execute: async ({ path, content }) => {
    await fs.writeFile(path, content);
    return { success: true, path };
  },
});

// Agent with persistent memory
const codeReviewAgent = new Agent({
  name: 'CodeReviewer',
  description: 'Reviews and improves code quality',
  model: 'gemini-pro',
  tools: [readFileTool, analyzeCodeTool, writeFileTool],
  memory: new Memory({
    type: 'persistent',
    storage: 'sqlite',
    dbPath: './agent-memory.db',
  }),
  systemPrompt: `
    You are an expert code reviewer.
    Analyze code for:
    - Security vulnerabilities
    - Performance issues
    - Best practices violations
    - Code style consistency

    Provide actionable suggestions with examples.
  `,
});

// Run code review
const review = await codeReviewAgent.run({
  message: 'Review the file src/auth/login.ts and suggest improvements',
});

Multi-Agent Orchestration

ADK supports multiple agents working together:

Collaborative Agent System

import { Agent, Orchestrator } from '@google/adk';

// Frontend specialist agent
const frontendAgent = new Agent({
  name: 'FrontendExpert',
  description: 'Expert in React, Vue, and frontend technologies',
  model: 'gemini-pro',
  tools: [/* frontend-specific tools */],
});

// Backend specialist agent
const backendAgent = new Agent({
  name: 'BackendExpert',
  description: 'Expert in Node.js, databases, and APIs',
  model: 'gemini-pro',
  tools: [/* backend-specific tools */],
});

// DevOps specialist agent
const devopsAgent = new Agent({
  name: 'DevOpsExpert',
  description: 'Expert in CI/CD, Docker, and cloud infrastructure',
  model: 'gemini-pro',
  tools: [/* devops-specific tools */],
});

// Orchestrator that coordinates agents
const orchestrator = new Orchestrator({
  agents: [frontendAgent, backendAgent, devopsAgent],
  routingStrategy: 'smart', // Uses AI to route tasks
  fallbackAgent: backendAgent,
});

// The orchestrator decides which agent to use
const response = await orchestrator.run({
  message: 'Set up a CI/CD pipeline for our React + Node.js application',
});

// The orchestrator routes to devopsAgent and coordinates
// with frontendAgent and backendAgent if necessary

Integration with JavaScript Ecosystem

One of the biggest advantages of ADK is native integration with the JavaScript ecosystem:

Using Existing Libraries

import { Agent, Tool } from '@google/adk';
import Stripe from 'stripe';
import { Octokit } from '@octokit/rest';
import nodemailer from 'nodemailer';

// Payment tool with Stripe
const stripePaymentTool = new Tool({
  name: 'process_payment',
  description: 'Process a payment using Stripe',
  parameters: {
    amount: { type: 'number', required: true },
    currency: { type: 'string', required: true },
    customerId: { type: 'string', required: true },
  },
  execute: async ({ amount, currency, customerId }) => {
    const stripe = new Stripe(process.env.STRIPE_KEY!);

    const paymentIntent = await stripe.paymentIntents.create({
      amount,
      currency,
      customer: customerId,
    });

    return { paymentId: paymentIntent.id, status: paymentIntent.status };
  },
});

// GitHub tool
const githubIssueTool = new Tool({
  name: 'create_github_issue',
  description: 'Create an issue on GitHub',
  parameters: {
    repo: { type: 'string', required: true },
    title: { type: 'string', required: true },
    body: { type: 'string', required: true },
  },
  execute: async ({ repo, title, body }) => {
    const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
    const [owner, repoName] = repo.split('/');

    const issue = await octokit.issues.create({
      owner,
      repo: repoName,
      title,
      body,
    });

    return { issueUrl: issue.data.html_url, issueNumber: issue.data.number };
  },
});

// Support agent with multiple integrations
const supportAgent = new Agent({
  name: 'CustomerSupport',
  model: 'gemini-pro',
  tools: [stripePaymentTool, githubIssueTool, emailTool],
  systemPrompt: `
    You are a customer support agent.
    You can:
    - Process refunds via Stripe
    - Create bug reports on GitHub
    - Send confirmation emails

    Always be helpful and professional.
  `,
});

Comparison with Other Frameworks

ADK enters a competitive market. See how it compares:

Framework	Language	Focus	Strengths
Google ADK	TypeScript/JS	Code-first	JS ecosystem, type safety
LangChain	Python/JS	Flexibility	Large community, many integrations
Vercel AI SDK	TypeScript	Streaming	Next.js integration, React hooks
AutoGPT	Python	Autonomy	Fully autonomous agents
CrewAI	Python	Multi-agent	Agent collaboration

Ecosystem Numbers

The market for AI agent frameworks in TypeScript is growing:

Weekly npm downloads:

Vercel AI SDK: 2.8 million
LangChain.js: 795 thousand
Google ADK: rapid growth since launch

TypeScript adoption:

69% of enterprise applications use TypeScript
TypeScript surpassed Python on GitHub in 2025

Best Practices

When building agents with ADK, follow these recommendations:

Project Structure

src/
├── agents/
│   ├── research-agent.ts
│   ├── code-review-agent.ts
│   └── support-agent.ts
├── tools/
│   ├── web-search.ts
│   ├── file-operations.ts
│   └── api-integrations.ts
├── memory/
│   └── storage-config.ts
├── orchestrators/
│   └── main-orchestrator.ts
└── index.ts

Error Handling

import { Agent, AgentError, ToolError } from '@google/adk';

const agent = new Agent({
  name: 'SafeAgent',
  model: 'gemini-pro',
  tools: [riskyTool],
  onError: async (error) => {
    if (error instanceof ToolError) {
      // Tool failed, try alternative
      console.error(`Tool ${error.toolName} failed:`, error.message);
      return { retry: true, fallbackMessage: 'Let me try another approach...' };
    }

    if (error instanceof AgentError) {
      // Model error, log and notify
      await notifyAdmins(error);
      return { abort: true, message: 'I encountered an issue. A human will follow up.' };
    }

    throw error; // Unknown error
  },
});

Conclusion

Google Agent Development Kit represents a significant shift in how JavaScript/TypeScript developers can build AI agents. The code-first approach, combined with type safety and native integration with the npm ecosystem, makes agent development accessible to millions of web developers.

If you already know TypeScript, you already have the fundamental skills to build AI agents. ADK simply provides the right abstractions to orchestrate language models with external tools.

If you feel inspired by the power of AI agents, I recommend checking out another article: MCP Protocol from Anthropic: The USB-C of AI where you will discover how standardized protocols are transforming communication between agents.