cloudparts

Genkit

Google’s Apache 2.0 framework for putting model calls, tools, RAG and agents into app backends, with SDKs for TypeScript, Go, Dart and Python and a local Developer UI that traces every step.

What it is
Agent frameworks
Used for
Retrieval-augmented generation (RAG)
Type
Open source
Made by
Google
License
Apache 2.0
Facts checked
13 October 2026
Website Source code

What it is

Genkit wraps model providers behind one generate() call, configured through plugins: Gemini through the Gemini API or Gemini Enterprise, Anthropic Claude, OpenAI, xAI, DeepSeek, Bedrock, Azure AI Foundry, Ollama for local models and any OpenAI-compatible API. Around that call it adds structured output validated against a schema, tools the model can call (defined with defineTool and a Zod or Go-struct schema), prompt templates in Dotprompt files, retrievers and embedders for RAG, and MCP, both to use tools from MCP servers and to expose Genkit tools as an MCP server. The unit you deploy is a flow: a typed function with input and output schemas that wraps your AI logic, can stream, and becomes an HTTP endpoint on Cloud Functions for Firebase, Cloud Run, AWS Lambda, Azure Functions or any server.

During development, genkit start -- <your run command> attaches the Developer UI (on localhost:4000) to your running process. It finds the flows, prompts, models, tools, retrievers and evaluators you defined and lets you run each one and inspect the trace of every model call and tool invocation. A newer Agents API (in beta, imported from genkit/beta) adds the conversational layer: message history, streaming, tool turns, interrupts for human approval, session stores, background turns and delegation to sub-agents, behind a chat() interface that a browser or mobile client can call remotely. TypeScript, Go and Dart are generally available; Python is in preview. The framework is free; you pay only for the models and hosting you choose.

Why teams pick it

  • Four languages on the same concepts: TypeScript (1.0 in February 2025), Go (1.0 in September 2025), Dart (1.0 in October 2026) and Python
  • The local Developer UI and CLI let you run any flow, prompt or tool and read full traces before writing a frontend
  • Model-agnostic through plugins, with switching models a one-line change, and deploys to Google, AWS, Azure or any host
  • Flows give typed, schema-validated inputs and outputs, so an AI feature becomes a normal, testable backend endpoint

Watch out for

  • The Agents API is in beta and can make breaking changes in minor releases
  • The Python SDK is still in preview (0.12 in September 2026), behind the TypeScript, Go and Dart SDKs
  • The CLI and Developer UI send usage analytics to Google by default; turn them off with genkit config set analyticsOptOut true

Alternatives

What all agent frameworks have in common →Compare side by side →
LangChainOpen sourceAn MIT-licensed Python and JavaScript framework whose create_agent runs the model and tool-calling loop for you, with one interface over many model providers and middleware hooks around every step.LangGraphOpen sourceA low-level MIT-licensed runtime for agents written as graphs of nodes over shared state, which checkpoints that state after every step so a run can pause for a human, survive a crash and resume where it stopped.Strands AgentsOpen sourceAWS’s Apache 2.0 toolkit for building agents in Python and TypeScript: an SDK whose agent is a model, a system prompt and a list of tools run in a loop inside your own process, plus a ready-made harness, sandboxes and evals built on it.

How it fits with other technologies

A typed flow that wraps a model call (npm i genkit @genkit-ai/google-genai) · ts

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

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

export const menuSuggestionFlow = ai.defineFlow(
  {
    name: 'menuSuggestionFlow',
    inputSchema: z.object({ theme: z.string() }),
    outputSchema: z.object({ menuItem: z.string() }),
  },
  async ({ theme }) => {
    const { text } = await ai.generate({
      model: googleAI.model('gemini-flash-latest'),
      prompt: `Invent a menu item for a ${theme} themed restaurant.`,
    });
    return { menuItem: text };
  },
);

See it in a real stack

No architecture uses Genkit yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2024–2026

By 2024 AI features were moving from research into apps, but taking them past a prototype, then evaluating and running them at scale, was hard. The Firebase team at Google introduced Firebase Genkit at Google I/O on 14 May 2024 as an open-source beta for JavaScript and TypeScript developers building Node.js backends, with Go promised. Its pitch was code-first AI development with local tooling: a developer UI for trying prompts and flows and reading traces, and deployment to Firebase or Google Cloud.

Genkit for Node.js reached 1.0 on 12 February 2025, followed by Go 1.0 on 10 September 2025 with a compatibility promise for all 1.x releases. The project then dropped “Firebase” from its name, moved its documentation from firebase.google.com to genkit.dev and its code to the genkit-ai GitHub organization, and added Python and Dart SDKs; Dart reached 1.0 on 8 October 2026.

Why it’s built this way

Code-first flows instead of a visual builder
The team wanted AI features to feel like ordinary application code with a minimal learning curve, so a flow is a plain function with schemas that you test, version and deploy like the rest of the backend.
Local developer tooling from day one
Iterating on prompts, tools and retrieval is mostly inspecting what the model saw and returned, so Genkit shipped a local UI that runs components and shows full traces before anything is deployed.
Plugins for models and vector stores
A plugin system let Google’s own models and third-party ones (Anthropic, OpenAI, Ollama and others) sit behind the same generate() call, so apps aren’t tied to one provider.

Timeline

  1. 2024

    Firebase Genkit launched in beta at Google I/O for Node.js

  2. 2025

    Genkit for Node.js 1.0, production-ready; Go in alpha

  3. 2025

    Genkit Go 1.0, the first stable Go release

  4. 2026

    Genkit Python 0.12 adds generative UI with A2UI

  5. 2026

    Genkit Dart 1.0 for Dart and Flutter apps

Sources8 · facts checked 13 October 2026

Improve this page on GitHub