Genkit vs ADK: A Guide to Choosing the Right Google AI Framework

Published: Jan 24, 2026 · Updated: May 16, 2026

Google offers two open-source frameworks for AI development: Genkit and Agent Development Kit (ADK).

Both can leverage Google’s large language models (Gemini), but they differ in their target use cases, architecture, and developer-facing features.

This article compares Genkit and ADK across use cases, platform integrations, model support, development style, and maturity to help you understand the differences and choose the right framework for your project.

For the time-pressed: The Genkit team’s subreddit r/GenkitFramework has a clear breakdown of when to use which, written from inside Genkit:

if you’re looking for the rich enterprise features of Agent Platform, and want to build multi-agent standalone systems, ADK is for you.

if you’re looking to add Gen AI or agentic features into your app, or want to build agents with lower level components especially using a variety of platforms and models, Genkit is the way to go.

That’s the gist. The rest of this article fills in background, history, latest moves, and code examples.

TL;DR

Aspect	Genkit	ADK
Primary Use Case	Adding GenAI features to apps (chat, summarization, RAG, etc.)	Building multi-agent systems with collaborative agents
Languages	Node.js (GA), Go (GA), Python (Beta), Dart (Preview)	Python (GA), Go (GA), Java (GA), TypeScript (GA)
Design Philosophy	Developer explicitly controls the flow	LLM dynamically decides agent delegation
Deployment	Cloud Run, GKE, Vercel, or anywhere	Anywhere, with deep Gemini Enterprise Agent Platform integration

The choice depends on the complexity of your problem and your team’s preferred language. They’re independent OSS frameworks running in parallel, not merged.

Framework Overview

Genkit

Genkit is a framework designed to simplify adding AI capabilities to your applications.

Originally developed by the Firebase team, it became an independent product after a Google reorganization and now sits alongside Flutter, Dart, and Go in the developer platforms organization.

Use plugins and templates to integrate various generative AI models and quickly build AI features.

Genkit - Open-source AI framework by Google

Open-source framework for building AI-powered apps with unified APIs for Google Gemini, GPT, Claude, and more.

🔗 genkit.dev

Key Features:

Languages:
- Node.js (GA Feb 2025)
- Go (GA Sep 2025)
- Python (Beta since Feb 2026)
- Dart (Preview)
- Java (community implementation genkit-ai/genkit-java, 1.0.0-SNAPSHOT under active development)
Runtime: Deploy anywhere — Cloud Run, GKE, Vercel, on-premise, etc.
Model Support: Gemini, OpenAI, Anthropic Claude, Ollama, and more via plugins
Developer Experience: Local Developer UI for prompt testing, step-by-step traces, and schema validation
Multi-agent: Beta support via the prompt-as-tool pattern
Middleware: Cross-cutting extensions across Generate / Model / Tool layers (guardrails, caching, retries, HITL approval). Announced May 2026, available in TypeScript / Go / Dart (Python planned)

Genkit Dart is also under active development as a full Genkit SDK for Dart. With model plugins (genkit_google_genai, genkit_firebase_ai), flow/tool definitions, and server-side HTTP hosting via genkit_shelf, it offers capabilities comparable to the Node.js and Go SDKs — opening up possibilities for both server-side Dart and Flutter applications.

Agent Development Kit (ADK)

ADK is a toolkit specialized for building sophisticated AI agent systems. It provides a foundation for complex multi-agent scenarios involving coordination between agents and external tool integrations.

Agent Development Kit

Build powerful multi-agent systems with Agent Development Kit.

🔗 google.github.io

Key Features:

Languages:
- Python (GA May 2025, ~10 months ahead of the others; v2.0 is Python-only and in Beta phase)
- Go (v1.0 stable, Mar 2026)
- Java (v1.0 stable, Mar 2026)
- TypeScript (v1.0 stable, Apr 2026)
Runtime: Deploy to any container environment — Cloud Run, GKE, etc. Deep integration with Gemini Enterprise Agent Platform (the evolution of Vertex AI, rebranded at Cloud Next 26 in April 2026) and its Agent Runtime (formerly Agent Engine)
Model Support: Gemini via Agent Platform, plus other models through LiteLLM adapters
Developer Experience: Local dev UI (adk web), CLI evaluation tool (adk eval)
Multi-agent: First-class support for Agent, Tool, Sub-agent, and workflow orchestration
Enterprise Connectors: 100+ connectors via ApplicationIntegrationToolset — Salesforce, ServiceNow, JIRA, SAP, and more. Built-in tools added since: Vertex AI Search Tool, UrlContextTool, SkillToolset, Spanner Admin Toolset, Apigee model integration

Companies like Renault Group, Box, and Revionics are already building systems with ADK.

Key Differences

Design Philosophy

These aren’t competing frameworks — they operate at different layers.

A Google engineer working on Genkit summarized its role this way:

Genkit focuses on “low-layer” AI APIs: models, tools, prompts, MCP, and developer tools like o11y tooling and playgrounds. Genkit lets you interact directly with LLMs, ships without hardcoded prompts by default, and its o11y tooling lets you see exactly what your agent is doing.

From this perspective:

Genkit is a low-layer AI framework. It focuses on models, tools, prompts, MCP, and o11y. You can use it standalone to build agents, or as a foundation for higher-layer frameworks.
ADK is a high-layer agent framework. It comes with batteries included — session management, memory, evaluation, and tight Gemini Enterprise Agent Platform integration.

The Genkit team has framed it on Discord as: ADK is purpose-built for agents and opinionated about how multi-agent systems are constructed, while Genkit is a general-purpose GenAI toolkit that takes fewer strong opinions on the specific construction of agents. In short: Genkit is flexible, ADK is specialized for multi-agent construction — pick by requirement.

Comparison Table

Aspect	Genkit	ADK
Primary Use Case	General GenAI integration (chatbots, summarization, recommendations, RAG, etc.)	Complex agent systems with multiple collaborating agents
Languages	Node.js (GA), Go (GA), Python (Beta), Dart (Preview)	Python (GA), Go (GA), Java (GA), TypeScript (GA)
Development Style	Code-defined flows, explicit control	Agent-centric, LLM-driven orchestration
Multi-agent	Beta (prompt-as-tool pattern); Middleware for cross-cutting extensions	First-class (Sequential / Parallel / Loop; graph-based Workflow in v2.0 Beta)
Deployment	Cloud Run, GKE, Vercel, anywhere	Anywhere; best fit with Gemini Enterprise Agent Platform / Agent Runtime
Model Flexibility	Switch between Gemini / OpenAI / Anthropic / Ollama and more via Genkit plugins	Gemini-centric via Agent Platform, with other vendors via LiteLLM
Maturity	Node GA (Feb 2025), Go GA (Sep 2025), Python Beta (Feb 2026~), Dart Preview	Python GA (May 2025), Go / Java / TS reached v1.0 stable in Mar-Apr 2026, Python v2.0 in Beta

Architecture Patterns

Genkit: Flow Orchestration

Genkit uses a style where you explicitly define the workflow (flow).

You write the processing steps in code: “generate text with LLM A → process the result → execute function B → …”. Genkit provides unified APIs like ai.generate(), structured data output, and function calling through plugins, making these steps easy to implement concisely.

TypeScript Example:

import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/google-genai';

const ai = genkit({ plugins: [googleAI()] });

const { text } = await ai.generate({
    model: googleAI.model('gemini-2.5-flash'),
    prompt: 'Why is Genkit awesome?'
});

Go Example:

import (
    "context"
    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
    ctx := context.Background()
    g := genkit.Init(ctx, genkit.WithPlugins(&googlegenai.GoogleAI{}))

    resp, _ := genkit.Generate(ctx, g,
        ai.WithModel(googlegenai.GoogleAIModel("gemini-2.5-flash")),
        ai.WithPrompt("Why is Genkit awesome?"),
    )
    fmt.Println(resp.Text())
}

With function calling, the LLM can behave like a semi-autonomous agent that invokes defined functions as needed, but you still control the overall flow.

ADK: Agent-Centric Orchestration

ADK uses an agent-oriented architecture.

You define agents (Agent classes), each with its own role (instruction prompts) and available tools or sub-agents.

ADK supports multiple patterns for sub-agent coordination:

sub_agents pattern: The LLM automatically generates transfer_to_agent calls to delegate control to sub-agents
AgentTool pattern: Wrap sub-agents as tools that the root agent can invoke

Here’s an example of the AgentTool pattern, where sub-agents have their own tools and are called as “tools” by the root agent:

from google.adk.agents import Agent
from google.adk.tools import AgentTool, ToolContext

# --- Sub-agent 1: Goal Setting ---
def get_user_goal(tool_context: ToolContext) -> dict:
    """Retrieves the user's current health goal from session state."""
    goal = tool_context.state.get("health_goal")
    if goal is None:
        return {"status": "not_set", "message": "No goal set yet."}
    return {"status": "success", "health_goal": goal}

def set_user_goal(tool_context: ToolContext, goal_type: str, description: str) -> dict:
    """Sets the user's health goal in session state."""
    tool_context.state["health_goal"] = {"goal_type": goal_type, "description": description}
    return {"status": "success", "message": f"Goal set: {goal_type}"}

goal_setting_agent = Agent(
    name="goal_setting_agent",
    description="Handles health goal setting and retrieval.",
    instruction="You help users set and check their health goals.",
    tools=[get_user_goal, set_user_goal],
)

# --- Sub-agent 2: Meal Advisor ---
meal_advisor_agent = Agent(
    model="gemini-2.5-flash",
    name="meal_advisor_agent",
    description="Provides meal recommendations based on user goals.",
    instruction="You suggest meals considering the user's health goals and calorie targets.",
)

# --- Root Agent ---
root_agent = Agent(
    model="gemini-2.5-flash",
    name="health_advisor",
    description="Main health advisor agent",
    instruction="""You are a health advisor assistant.

## Your Role
- Understand user requests and delegate to appropriate sub-agents
- Use goal_setting_agent for goal-related queries
- Use meal_advisor_agent for meal recommendations

## Direct Response Cases
- Greetings: respond directly
- General health questions: respond directly
""",
    tools=[
        AgentTool(agent=goal_setting_agent),
        AgentTool(agent=meal_advisor_agent),
    ],
)

The root agent delegates to appropriate sub-agents based on LLM reasoning. Each sub-agent has its own tools and instructions to handle specialized tasks.

ADK also provides workflow control agents:

SequentialAgent: Run agents in sequence
ParallelAgent: Run agents in parallel
LoopAgent: Repeat until a condition is met

ADK 2.0 (Beta): Graph-based Workflow Runtime

In April 2026, ADK entered v2.0 Beta phase. The core of v2.0 is a graph-based Workflow runtime that lets you express task routing, fan-out / fan-in, loops, retries, human-in-the-loop approval, and nested workflows explicitly as a graph. Combined with the new Task API, agent-to-agent delegation can carry typed input / output contracts — handling more complex branching than Sequential / Parallel / Loop allows.

That said, v2.0 is Python-only and Beta at the time of writing. v1.x continues for production use, and v1.x and v2.0 can coexist in the same process (compatibility maintained). You don’t need to migrate to v2.0 right now — if Sequential / Parallel / Loop covers your needs, staying on v1.x is fine. v2.0 becomes a candidate when complex graph orchestration enters the picture.

ADK 2.0 (Beta)

Graph-based Workflow runtime and Task API for ADK Python.

🔗 adk.dev

Decision Guide

Scenario / Condition	Recommendation	Reason
Quickly add simple AI features to an app	Genkit	Chatbots, summarization, RAG. Prioritize development speed
Complex AI system with multiple specialized agents	ADK	Multiple data sources/tools, need role separation
Team primarily writes TypeScript / JavaScript	Genkit	Node.js support, leverage web frontend experience
Team primarily writes Python	ADK	Leverage ML and data processing experience. Python is GA
Team primarily writes Go	Either works	Genkit Go is GA, ADK Go is available
Need to connect to Google Cloud data / enterprise systems	ADK	Rich connectors for BigQuery, Salesforce, ServiceNow, etc.
Want flexibility for various AI use cases in the future	Genkit	High extensibility through plugins

Choosing by Language

Now that ADK supports Python, TypeScript, Go, and Java, and Genkit supports Node.js, Go, Python, and Dart, language preference alone rarely decides the choice.

However, maturity varies:

Language	Genkit	ADK
TypeScript/Node.js	GA	v1.0 stable (Apr 2026)
Go	GA	v1.0 stable (Mar 2026)
Python	Beta (since Feb 2026)	v1.x GA + v2.0 Beta
Dart	Preview	Not supported
Java	Community implementation (1.0.0-SNAPSHOT)	v1.0 stable (Mar 2026)

If your team writes Python and prioritizes production stability, ADK (v1.x GA since May 2025, well-proven) is the natural choice — and v2.0 Beta is on the table if you want to explore graph-based orchestration. For Go teams, both Genkit Go and ADK Go are at v1.x stable, so the decision comes down to use case (embedding AI / agentic features into an app vs building a standalone multi-agent system). Dart / Flutter teams: Genkit Dart (Preview) is the realistic option. Java teams: ADK v1.0 is the solid pick, and Genkit Java is moving at 1.0.0-SNAPSHOT if you want to try Genkit patterns in Java.

Developer Tooling Integration

Both sides are wiring up integrations with AI development tools (Gemini CLI, Claude Code, Codex, and others) so you can drive agent development through natural language.

Genkit: The Genkit Extension for Gemini CLI ships MCP tools for flow execution, doc lookup, and trace analysis, plus code generation aligned with Genkit patterns. See the repo for install instructions.

ADK: Agents CLI (open source, Apache-2.0) handles scaffolding / eval / deploy / observability for ADK agents. Subcommands like scaffold, eval run, deploy, publish gemini-enterprise plus seven skill bundles that AI coding tools can load for ADK-specific workflows. See the official docs for installation and setup.

Both push agent development toward “let the tools do it” — pick them up once you’ve settled on Genkit or ADK and want to accelerate the build loop.

Learning Path and Combination Patterns

From Low-Layer to High-Layer

A common recommendation shared in the Genkit community is to follow Anthropic’s “Building effective agents” guidance.

When you’re starting out, it often makes sense to begin with a low-layer toolkit like Genkit to deeply understand models, tools, prompts, and o11y, then adopt a high-layer framework like ADK based on your application’s requirements.

Once you have this foundation, you can work with ADK or any other framework.

Split by Use Case First, Then Combine

Rather than thinking of these as “complementary layers,” it’s closer to Google’s current public stance to split by use case first. On social media, the framing often goes:

Have an app (web, mobile, etc)? Want to add agentic features to it? Use Genkit!

Building complex, standalone, multi-agent systems? E.g. on GCPs Agent Platform? Use ADK.

Choose Genkit when: You have an existing app (web / mobile / API backend) and want to add AI / agentic features — chat, summarization, RAG, tool calls. Easier to get started, more ergonomic for app developers
Choose ADK when: You’re building a standalone complex system on Agent Platform where multiple agents collaborate, with enterprise requirements (connectors, governance, evaluation) at the forefront

If you want both, you can combine them — e.g., call a separately-deployed ADK agent from a Genkit-powered API backend. But you don’t have to design for “combination first.” Figure out which side your use case leans toward, then bridge later when the need arises.

Summary

Think of Genkit and ADK as complementary layers rather than competing choices.

Layer	Framework	Focus
Low-layer	Genkit	Models, tools, prompts, MCP, o11y
High-layer	ADK	Session management, memory, evaluation, multi-agent orchestration

Start with Genkit to understand AI fundamentals, then consider ADK when requirements get complex. Or combine them — use Genkit as a foundation with ADK on top. This flexibility is a strength of Google’s AI framework ecosystem.