Genkit | Blog

Announcing Genkit Dart 1.0: Build production-ready agentic apps with Dart and Flutter

Thu, 08 Oct 2026 12:00:00 GMT

This announcement was cross-posted from the official Flutter blog.

Dart and Flutter let you build high-quality apps for mobile, web, and desktop from a single codebase. With Genkit Dart, you can bring that same productivity to full-stack, agentic apps.

Today, we’re announcing Genkit Dart 1.0, the first stable, production-ready release of Google’s open-source framework for building AI-powered features and agents in Dart. Since our preview launch earlier this year, feedback from the Dart and Flutter community has helped us refine the APIs and expand the toolkit for production workloads.

To get started, add genkit to your project:

dart pub add genkit

You can also install the agent skill to give AI coding assistants like Antigravity, Claude Code, and Codex up-to-date knowledge of Genkit Dart APIs and best practices:

npx skills add genkit-ai/skills

Why Genkit Dart

Genkit provides a unified API across model providers, end-to-end type safety between your server and client, and local tooling to test and debug your AI workflows.

Use any model with one API

Genkit supports Google Gemini, Anthropic Claude, OpenAI, and OpenAI-compatible models through a single interface. You register model providers as plugins and can switch between models without rewriting your application logic:

final ai = Genkit(plugins: [googleAI(), anthropic()]);
final prompt = 'Suggest a weekend getaway from San Francisco.';

final fromGemini = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: prompt,
);

final fromClaude = await ai.generate(
  model: anthropic.model('claude-sonnet-5-5'),
  prompt: prompt,
);

End-to-end type safety with flows

Genkit lets you wrap your AI logic into flows: strongly typed, observable functions that are easy to test and deploy as HTTP endpoints. Using the schemantic package, you can define your data schemas once in Dart, generate structured output from the model, and share those exact types between your backend and your Flutter app:

// shared/lib/models.dart (used by both server and app)
@Schema()
abstract class $TripRequest {
  String get destination;
  int get days;
}
// ...plus an Itinerary schema for the result.

// server/bin/server.dart
final planTrip = ai.defineFlow(
  name: 'planTrip',
  inputSchema: TripRequest.$schema,
  outputSchema: Itinerary.$schema,
  fn: (request, _) async {
    final response = await ai.generate(
      model: googleAI.gemini('gemini-flash-latest'),
      prompt: 'Plan a ${request.days}-day trip to ${request.destination}.',
      outputSchema: Itinerary.$schema,
    );
    return response.output!;
  },
);
await (GenkitRouter()..addAction(planTrip)).serve(port: 8080); // POST /planTrip

// app/lib/main.dart
final planTrip = defineRemoteAction(
  url: 'https://api.example.com/planTrip', // Your Genkit endpoint
  inputSchema: TripRequest.$schema,
  outputSchema: Itinerary.$schema,
);
final itinerary = await planTrip(
  input: TripRequest(destination: 'Kyoto', days: 5),
);

Run anywhere Dart runs

Because your AI logic is written in standard Dart, you get fast iteration with hot reload and the flexibility to run your code wherever it fits your architecture:

Directly in Flutter: Call models straight from your app for rapid prototyping or bring-your-own-key experiences (never embed private API keys in a published client app).
On a Dart server: Run complex flows and keep sensitive prompts on the backend, then call them from Flutter using defineRemoteAction as shown above.
In Flutter with remote models: Keep your AI logic in the Flutter app while routing model requests through a lightweight Genkit backend that protects your API keys and enforces authorization:

server/bin/server.dart

final genkit = GenkitRouter()
  ..addAction(
    googleAI().model('gemini-flash-latest'),
    path: '/gemini',
    // Runs before the model; throw a GenkitException to reject the request.
    contextProvider: (request) async =>
        {'user': await verifyUser(request.headers['authorization'])},
  );
await genkit.serve(port: 8080);

// app/lib/main.dart
final ai = Genkit();
final gemini = ai.defineRemoteModel(
  name: 'gemini',
  url: 'https://api.example.com/gemini',
  headers: (context) async => {'Authorization': 'Bearer ${await getIdToken()}'},
);
final response = await ai.generate(
  model: gemini,
  prompt: 'Suggest a packing list for Kyoto in April.',
);

Test and debug with the Developer UI

Genkit includes a local Developer UI for testing flows, experimenting with prompts, and inspecting execution traces step by step. Launch it alongside your Dart process using the Genkit CLI:

genkit start -- dart run bin/server.dart

Built for agentic workflows

Since the preview launch, we’ve expanded Genkit Dart with capabilities designed for multi-step agentic workflows, including human-in-the-loop interrupts, generation middleware, prompt management, and production telemetry.

Give models tools with human-in-the-loop interrupts

Tools let models call your Dart functions to fetch data or trigger actions, like searching for flights or booking a hotel. When an action requires user confirmation, a tool can pause the generation loop by returning .interrupt(...) instead of .response(...):

final bookHotel = ai.defineTool(
  name: 'bookHotel',
  description: 'Books a hotel room for the user.',
  inputSchema: HotelBooking.$schema,
  fn: (input, ctx) async {
    // Ask the user to confirm before charging their card.
    if (ctx.resumed == null) {
      return .interrupt({'hotel': input.hotelName, 'total': input.totalPrice});
    }
    final confirmation = await hotels.book(input);
    return .response(confirmation.id);
  },
);

Putting the approval check inside the tool guarantees that the model can’t bypass it. When generate returns with FinishReason.interrupted, your Flutter app can prompt the user for confirmation and resume execution from where it paused.

Extend generation with middleware

Middleware hooks directly into the generate loop to intercept model calls, inject tools, or modify requests and responses. Using genkit and genkit_middleware, you can attach prepackaged middleware like automatic retries, dynamic SKILL.md loading, and tool approval rules to any generate call:

final ai = Genkit(plugins: [googleAI(), SkillsPlugin(), ToolApprovalPlugin()]);

final response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'Move my Kyoto hotel check-in to Friday.',
  tools: [findBookings, updateBooking],
  use: [
    retry(maxRetries: 3),
    skills(skillPaths: ['./skills']),
    toolApproval(approved: ['findBookings', 'use_skill']),
  ],
);

You can also author custom middleware with defineGenerateMiddleware for cross-cutting logic like logging, caching, or model fallbacks.

Manage prompts with Dotprompt

Dotprompt lets you manage prompt templates, model configuration, and input/output schemas together in .prompt files. Genkit automatically loads prompts from your prompts/ directory so you can invoke them as callable functions in Dart:

---
model: googleai/gemini-flash-latest
input:
  schema:
    destination: string
---
Write a friendly, two-sentence introduction to {{destination}} for a first-time visitor.

final introPrompt = await ai.prompt('destinationIntro');
final response = await introPrompt({'destination': 'Kyoto'});

Monitor your app in production

When you’re ready to deploy, the genkit_otel package exports traces, token usage, and latency metrics using the OpenTelemetry GenAI semantic conventions, integrating directly with your existing observability backend:

import 'package:dartastic_opentelemetry/dartastic_opentelemetry.dart';
import 'package:genkit/telemetry.dart';
import 'package:genkit_otel/genkit_otel.dart';

await OTel.initialize();
configureInstrumentation(GenAiInstrumentation());

What’s next: stateful agents and generative UI

Alongside the stable 1.0 core, we’re developing higher-level agentic APIs under the package:genkit/experimental.dart import so you can try them early and help shape their design.

Stateful agents combine a model, tools, system instructions, and state into a single defineAgent call. Conversations persist across turns and app restarts using session stores, and you can use remoteAgent to delegate tasks to subagents or expose agents over HTTP to connect with your Flutter app:

import 'package:genkit/experimental.dart';

final travelAgent = ai.defineAgent(
  name: 'travelAgent',
  model: googleAI.gemini('gemini-flash-latest'),
  system: 'You help users plan and book trips.',
  tools: [searchFlights, bookHotel],
  store: FirestoreSessionStore(collection: 'sessions'),
);

final chat = travelAgent.chat(sessionId: 'user-123');
final response = await chat.send(text: 'Find me a weekend in Lisbon.');

Generative UI with A2UI lets agents stream interactive UI surfaces instead of plain text. With genkit_a2ui, an agent can emit components like date pickers, forms, and confirmation cards that your Flutter app renders incrementally as native widgets. Check out the A2UI guide to learn more.

Get started

Genkit Dart 1.0 is available on pub.dev today. Thank you to everyone in the Dart and Flutter community who built with the preview, reported issues, and contributed pull requests to help bring Genkit Dart to 1.0.

Get started: Follow the quickstart guide.
Explore samples: Browse the sample apps on GitHub.
Join the community: Chat with the team on Discord.
Stay updated: Follow Genkit on X and LinkedIn.
Give feedback: Open an issue on the GitHub repository.

We can’t wait to see what you build with Genkit Dart 1.0!

Genkit Python 0.12: Generative UI with A2UI, typed Pydantic streaming, and Deep Research and Lyria models

Thu, 24 Sep 2026 12:00:00 GMT

Genkit Python 0.12 makes it easier to build interactive, multimodal AI applications in Python. With the new genkit-a2ui package, your agents can render interactive UI components instead of plain text, and generate_stream now yields typed Pydantic model instances as tokens arrive. This release also adds support for Google’s Deep Research and Lyria 3 audio generation models, along with simpler error recovery during multi-step turns.

To start using this new version, run the following command in your terminal:

uv add genkit genkit-google-genai

Build interactive UIs with A2UI

Plain text is often not the best interface for tasks like booking a table, filtering search results, or filling out a form. The new genkit-a2ui package brings A2UI generative UI support to Genkit Python, letting your models respond with rich, interactive UI components.

Install the package alongside core Genkit:

uv add genkit-a2ui

Add Surfaces() to use on ai.generate or ai.define_agent to enable generative UI. Across multi-turn conversations, Surfaces() automatically tracks what is currently on screen and feeds user interactions, such as button clicks or form submissions, back into the conversation so the model can update the UI in place:

from genkit import Genkit
from genkit_a2ui import Surfaces, envelopes_from_parts
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()])

response = await ai.generate(
    model=GoogleAI.gemini_model('gemini-flash-latest'),
    prompt='Show me the current weather and forecast for Tokyo.',
    use=[Surfaces()],
)

print(envelopes_from_parts(response.message.content))

Out of the box, Surfaces() validates generated UI against a built-in catalog of common layout and input components, or you can register your own custom design system components with load_catalog.

Because A2UI uses a language-agnostic format, you can pair a Genkit Python backend with web frontends in JavaScript or TypeScript and multi-platform apps built with Dart and Flutter. Genkit’s client helpers (@genkit-ai/a2ui/client for JavaScript and package:genkit_a2ui/client.dart for Dart and Flutter) handle extracting streamed UI updates for your renderer and sending user actions back to your Python agent:

A Flutter client rendering an interactive Cymbal Bistro reservation form streamed from a Genkit Python agent with A2UI, then submitting the selected time slot and seating preference to confirm the booking.

Stream typed Pydantic models

When you stream structured outputs with output_schema, generate_stream now populates chunk.output with a partial Pydantic model instance instead of a raw dictionary. You get editor autocomplete and type-safe attribute access while rendering live UI updates as tokens arrive:

from pydantic import BaseModel
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(
    plugins=[GoogleAI()],
    model=GoogleAI.gemini_model('gemini-flash-latest'),
)


class Country(BaseModel):
    name: str
    capital: str
    population: int


sr = ai.generate_stream(
    prompt='Give quick facts about Japan.',
    output_schema=Country,
)

async for chunk in sr:
    if chunk.output and chunk.output.name:
        print(chunk.output.name)

final_country = (await sr.response).output
print(final_country)

As fields stream in, unset fields default to None and partial strings grow with each chunk. Once streaming completes, (await sr.response).output returns the fully validated Country instance.

Run Deep Research jobs and generate audio with Lyria 3

The genkit-google-genai plugin adds support for Google’s Deep Research agent and Lyria 3 audio generation models.

Deep Research plans and executes multi-step research tasks over several minutes. You can launch a research request in the background with generate_operation and poll for the completed report using check_operation:

import asyncio
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()])

operation = await ai.generate_operation(
    model=GoogleAI.deep_research_model('deep-research-preview-04-2026'),
    prompt='Summarize recent advances in quantum error correction for a technical audience.',
)

while not operation.done:
    await asyncio.sleep(10)
    operation = await ai.check_operation(operation)

print(operation.output)

To generate music and instrumental audio clips from text prompts, pass GoogleAI.lyria_model to ai.generate:

clip = await ai.generate(
    model=GoogleAI.lyria_model('lyria-3-clip-preview'),
    prompt='A short piano loop, rainy window.',
)

for part in clip.message.content:
    if part.media:
        print(part.media.url)

You can also experiment with lyria-3-clip-preview directly in the Genkit Developer UI and listen to generated audio clips right in the browser:

Generating and playing back an instrumental piano loop from a text prompt with lyria-3-clip-preview in the Genkit Developer UI.

Recover cleanly from mid-turn errors

Previously, if a model failed to match your output_schema or a tool call failed mid-turn, ai.generate raised an exception and discarded the conversation history and raw model output you needed to recover.

Now, ai.generate only raises GenkitError for setup mistakes before a turn starts, such as an invalid model name. Once a turn is underway, ai.generate always returns a ModelResponse so you can inspect response.error alongside the preserved response.messages and response.text to debug or retry without losing progress:

from genkit import Genkit, GenkitError
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()], model=GoogleAI.gemini_model('gemini-flash-latest'))

try:
    history = None
    for attempt in range(3):
        response = await ai.generate(
            prompt='Look up order #412 and process a refund.' if attempt == 0 else None,
            messages=history,
            tools=[lookup_order, process_refund],
        )
        if not response.error:
            break
        print(f'Turn failed ({response.error.reason}). Resuming...')
        # => Turn failed (TOOL_FAILED). Resuming...
        history = response.messages

    print(response.text)
    # => Looked up order #412 and issued an $85 refund.

except GenkitError as err:
    print(err.reason)
    # => MODEL_NOT_FOUND

Inside tools, you can also raise PublicError to pass safe, user-facing error messages back on response.error while unexpected exceptions stay masked.

Also in this release

Simpler Part API. You can now create message parts directly with Part(text='hello') and read part.text or part.media without unwrapping part.root.
Multipart tool responses. Tools can now return media attachments alongside structured JSON in a single tool response.
OpenAI plugin updates. genkit_openai adds support for gpt-6-astra and improves streaming for reasoning tokens, tool calls, and refusal metadata.
Per-request API keys. Multi-tenant apps can now pass per-request Gemini credentials through context={'secrets': {'api_key': tenant_key}}.

Get started

We can’t wait to see what you build with Genkit Python 0.12. Explore the Genkit Python documentation, check out the Python sample applications, or read the complete v0.12.0 release notes on GitHub.

Genkit Dart 0.17: Resumable generate and agent loops, async subagents, and pluggable telemetry

Mon, 21 Sep 2026 12:00:00 GMT

As we move toward a stable 1.0 release, Genkit Dart 0.17 brings resumable generation and agent snapshots, background subagents, and pluggable OpenTelemetry instrumentation. Failed or aborted generate calls and agent turns now preserve completed tool rounds so you can resume where execution stopped, and orchestrator agents can delegate long-running tasks to background subagents without blocking the main conversation. This release also keeps core free of OpenTelemetry dependencies via the new genkit_otel package and upgrades the genkit_openai, genkit_mcp, genkit_anthropic, and genkit_google_genai plugins.

To start using this new version, run the following command in your terminal:

dart pub add genkit

Resume incomplete generate calls

When a multi-turn tool loop ends early due to errors, turn limits, or cancellation, ai.generate now returns the intermediate state instead of throwing an exception. This lets you inspect progress and resume from where you left off, without repeating completed tool calls:

var response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'Search flights to Kyoto, then reserve a hotel.',
  tools: [searchFlights, bookHotel],
);

if (response.finishReason == FinishReason.failed ||
    response.finishReason == FinishReason.aborted) {
  // Completed tool rounds are preserved in response.messages:
  response = await ai.generate(
    model: googleAI.gemini('gemini-flash-latest'),
    messages: response.messages,
    tools: [searchFlights, bookHotel],
  );
}

The messages history preserves completed tool rounds and omits pending requests, so you can pass messages directly back into ai.generate to resume execution without duplicate calls.

Resume failed or aborted agent snapshots

Stateful agents bring this same crash recovery to persistent chat sessions. When an agent turn fails or is cancelled mid-flight, Genkit automatically checkpoints the user prompt and any completed tool calls into a session snapshot before throwing AgentError. Pass e.snapshotId back to agent.chat to resume the turn from that checkpoint instead of asking the user to start over:

final chat = travelAgent.chat(sessionId: sessionId);

try {
  final response = await chat.send(text: 'Book the full itinerary.');
} on AgentError catch (e) {
  // Resume from the saved checkpoint containing completed tool calls:
  if (e.status == 'UNAVAILABLE' && e.snapshotId != null) {
    final rerun = travelAgent.chat(snapshotId: e.snapshotId);
    final response = await rerun.send();
  }
}

Delegate work to background subagents

Regular subagents run inside a single tool call and block the main agent until every delegated task finishes, freezing the conversation during slow jobs like deep research reports or codebase audits. Setting async: true on the agents middleware lets your orchestrator launch subagents in the background and return a taskId immediately, so the main agent can reply to the user right away and keep the conversation moving while heavy work runs across turns.

Because background subagents run in their own tracked sessions outside the turn loop, the orchestrator can check in on progress, wait with a timeout to share partial results as faster tasks finish, cancel in-flight work the user no longer needs, or send follow-up instructions into a subagent’s existing session without starting over:

import 'package:genkit_middleware/agents.dart';

final researcher = ai.defineAgent(
  name: 'researcher',
  description: 'Researches a single topic and returns a concise summary.',
  system: 'Return a tight 3-4 sentence summary of the topic.',
  store: InMemorySessionStore(),
);

final orchestrator = ai.defineAgent(
  name: 'asyncOrchestrator',
  system: 'Coordinate multi-topic research requests in the background.',
  use: [
    agents(agents: ['researcher'], async: true),
  ],
  store: InMemorySessionStore(),
);

Here is asyncOrchestrator running in the Genkit Developer UI, returning "status": "pending" and a taskId for each delegated task so the main turn can reply immediately while the researcher subagents continue running in the background:

Pluggable telemetry and OpenTelemetry GenAI support

Core Genkit no longer pulls in OpenTelemetry dependencies by default, keeping your app’s footprint small while local tracing still works automatically with the Genkit Developer UI. When you deploy to production, install the new genkit_otel package and register GenAiInstrumentation with configureInstrumentation to export traces, token usage, and operation latency following the OpenTelemetry GenAI semantic conventions:

import 'package:dartastic_opentelemetry/dartastic_opentelemetry.dart';
import 'package:genkit/telemetry.dart';
import 'package:genkit_otel/genkit_otel.dart';

await OTel.initialize();
configureInstrumentation(
  GenAiInstrumentation(contentCapturingMode: ContentCapturingMode.spanOnly),
);

final ai = Genkit(plugins: [googleAI()]);

Also in this release

Updated OpenAI model catalog. genkit_openai now ships with an updated catalog of chat and embedding models with preconfigured capability presets and typed shortcuts on OpenAIModels and OpenAIEmbedders.
Streamable HTTP and latest MCP spec. genkit_mcp is now powered by the official mcp_dart SDK, adding support for the latest Model Context Protocol specification and Streamable HTTP servers.
Multi-turn extended thinking for Anthropic. genkit_anthropic now preserves Claude’s reasoning blocks across multi-step tool loops so extended thinking stays intact throughout complex workflows.
Gemma discovery and deterministic seeds. genkit_google_genai adds built-in model discovery for Gemma alongside seed support for reproducible outputs.

Get started

We can’t wait to see what you build with Genkit Dart 0.17. Check out the Genkit Dart documentation, explore the sample applications, or read the release notes for genkit v0.17.0 and genkit_otel v0.1.0.

Genkit CLI & Dev UI 1.43: Improved human-in-the-loop testing and log viewing

Fri, 18 Sep 2026 12:00:00 GMT

Genkit CLI and Developer UI 1.43 makes it easier to test human-in-the-loop agents and inspect execution logs in both the browser and the terminal. You can now step through multiple tool interrupts in the Agent Runner, view execution logs alongside trace spans in a dedicated bottom drawer, and query logs from your terminal or coding agent with genkit log:list.

To install or upgrade to the latest version, run the following command in your terminal:

curl -sL cli.genkit.dev | bash

Step through human-in-the-loop interrupts in the Agent Runner

When an agent pauses execution for human review or external signoff, it often queues multiple pending tool calls within the same turn, such as reserving both a flight and a hotel before generating a final itinerary. Built on an interactive stepper, the Agent Runner now groups interrupted tool calls into a single Action Required card so you can inspect and resolve each request in order.

You can step forward and backward through pending tool requests using the Next and Previous controls, inspect the proposed input arguments, and choose how to resolve each call:

Respond with Output injects a JSON return value directly into the session history, bypassing the tool handler code.
Restart with Context re-executes the tool handler while passing additional verification metadata in the resumed context object.

When you reach the final tool request in the stepper, clicking Resume (or Submit responses in manual tool response mode) submits all tool resolutions together so the agent can complete its turn.

Top-level Trace Logs drawer in the Developer UI

Previously, trace logs lived inside a section within the right-hand Span Details panel, requiring you to scroll past lengthy span inputs and outputs to inspect log messages. In 1.43, the Logs panel has been promoted to an always-visible, resizable, collapsible bottom drawer spanning the full width of the Trace Viewer.

This layout lets you inspect the span execution tree, span details, and correlated runtime logs simultaneously. Each row displays a severity badge, timestamp, and an inline preview of structured key-value attributes. Clicking any entry expands its full structured JSON payload together with its correlated traceId and spanId.

Query execution logs with `genkit log:list`

The new genkit log:list CLI command queries execution logs directly from the local telemetry server. This makes logs easy to inspect from your terminal and directly accessible to AI coding agents (such as Antigravity, Claude Code, or Cursor) for agent-driven debugging without copying payloads out of the browser.

You can filter logs by trace ID, span ID, or minimum severity (for example, --severity info returns INFO and above):

genkit log:list --trace-id 7b8e9a01c2d3e4f5a6b7c8d9e0f1a2b3 --severity info

By default, genkit log:list prints newest entries first in a readable summary format:

Found 3 logs:

ID:       9f4a21c0-88b1-4e2a-9c14-0a1b2c3d4e5f
Span ID:  1000000000000006
Severity: WARN
Time:     9/17/2026, 7:01:41 PM
Message:  Turn interrupted awaiting human approval
Attrs:    pendingTools=2, cluster=us-central1
---
ID:       7956edb0-15ac-4a78-a419-fcf698326392
Span ID:  1000000000000004
Severity: INFO
Time:     9/17/2026, 7:01:41 PM
Message:  Canary verification passed
Attrs:    status=HEALTHY, p99LatencyMs=42
---
ID:       cce5e07e-c686-4069-95da-efb18265f796
Span ID:  1000000000000002
Severity: INFO
Time:     9/17/2026, 7:01:40 PM
Message:  Saved session checkpoint snap-20260917-01
Attrs:    sessionId=sess-prod-rollout-9941
---

Also in this release

Python OTLP debug log streaming. Running Python workflows under genkit start now streams debug and higher lifecycle logs from ai.generate() to the Developer UI over OTLP while keeping your terminal output at the configured GENKIT_LOG level.
Composite badges for agent companion spans. Trace views now display composite two-icon badges (robot + secondary icon) for background agent actions including agent-snapshot, agent-wait, and agent-abort.
Bundled multipart artifact downloads. When an agent session artifact contains multiple files, downloading it from the Artifacts panel now bundles all parts into a single .zip archive instead of downloading files individually.
Java and Kotlin runtime detection. The CLI and telemetry server automatically detect java projects when pom.xml, build.gradle, or build.gradle.kts files are present in the project root.
Accessibility and theme refinements. Improved keyboard and screen-reader accessibility across trace and navigation views, and synchronized JSON editor colors across light and dark themes.

Get started

Upgrade to Genkit CLI and Developer UI 1.43 today to try human-in-the-loop agent stepping, the Trace Logs drawer, and genkit log:list. Explore the Genkit Developer Tools documentation for guides, or read the full 1.43.0 release notes on GitHub.

Genkit Go 1.13: Resumable generate and agent loops, async subagents, and A2UI

Thu, 03 Sep 2026 12:00:00 GMT

Genkit Go 1.13 brings resumable agent control flow, background subagents, and streaming interactive UI. Generate calls and agent turns now keep their progress when they fail or get cancelled, so you can resume them at any time. Subagents can run in the background while the orchestrator keeps working, and with the new A2UI (Agent-to-User Interface) plugin, an agent can stream interactive surfaces straight to the frontend.

To start using this new version, run the following command in your terminal:

go get github.com/firebase/genkit/go@latest

Keep progress across interrupted generate calls

When you’re in the middle of a multi-step tool loop, you don’t want an error on step five to cause you to lose all of your progress.

Now Generate returns what it finished alongside the error. Send it right back to retry the failed step without redoing the tool calls that already worked:

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("Plan the trip."),
    ai.WithTools(searchFlights, bookHotel),
)
if err != nil && resp != nil {
    // resp.FinishReason: Failed (error encountered) or Aborted (cancelled).
    // resp.Error: the cause, classified.
    // resp.History(): the tool rounds that finished, ready to send again.
    resp, err = genkit.Generate(ctx, g,
        ai.WithModelName("googleai/gemini-flash-latest"),
        ai.WithMessages(resp.History()...),
        ai.WithTools(searchFlights, bookHotel),
    )
}

History() stops at a clean turn boundary: the completed rounds, nothing half-done, so any provider accepts it. Streaming works the same way: GenerateStream yields the partial response next to its error.

Resume any agent turn, whether it succeeded, failed, or was aborted

Genkit agents bring the same resumability to stateful sessions. A turn that fails saves the tool rounds it completed as a failed snapshot. Send an empty input to run the turn again on what was saved:

out, err := agent.RunText(ctx, "Book the full itinerary.")
if out.FinishReason == aix.AgentFinishReasonFailed {
    // out.Error has the status. Transient? Run the turn again:
    // no new message, no repeated tool calls.
    out, err = agent.Run(ctx, &aix.AgentInput{},
        aix.WithSessionID[any](out.SessionID))
}

If you cancel the context, hit a deadline, or exhaust your turn limit, the agent saves an aborted snapshot with completed turns intact. Run returns this output alongside the error so you know exactly where execution stopped:

out, err := chatAgent.Run(ctx, &aix.AgentInput{Message: msg}) // ctx cancelled
if out.FinishReason == aix.AgentFinishReasonAborted {
    out, err = chatAgent.Run(context.Background(), &aix.AgentInput{},
        aix.WithSnapshotID[any](out.SnapshotID))
}

Whether a failure is worth retrying is your call. The runtime saves the snapshot and the classified error and gets out of the way. Detached runs get a proper aborting status while they wind down, so a stop never leaves a row stuck in pending.

Subagents run in the background

Setting Async: true on the Agents middleware enables background subagents. Each delegation tool gains a background flag that returns a task ID immediately, while three shared tools let the orchestrator check, wait for, or abort launched tasks:

researcher := genkitx.DefineAgent(g, "researcher",
    aix.InlinePrompt{
        ai.WithModelName("googleai/gemini-flash-latest"),
        ai.WithSystem("You are a thorough research assistant."),
    },
    aix.WithDescription[any]("Researches a topic and summarizes findings."),
    // Background work is tracked by a snapshot, so the subagent needs a store.
    aix.WithSessionStore(localstore.NewInMemorySessionStore[any]()),
)

orchestrator := genkitx.DefineAgent[any](g, "orchestrator",
    aix.InlinePrompt{
        ai.WithModelName("googleai/gemini-flash-latest"),
        ai.WithSystem("Delegate research and keep the user updated."),
        ai.WithUse(&middlewarex.Agents{
            Agents: []aix.AgentRef{researcher.Ref()},
            Async:  true,
        }),
    },
)

delegate_to_researcher    {task, background: true}    -> taskId, right away
check_background_tasks    {taskIds}                   -> where each one stands
wait_for_background_tasks {taskIds, timeoutSeconds?}  -> results as they settle
abort_background_tasks    {taskIds}                   -> stop, keep the progress
continue_task             {taskId, instructions?}     -> pick up where it left off

There is no separate task registry to maintain. The task ID lives directly in the tool result within the conversation history, allowing an orchestrator to resume tracking even after a restart. wait_for_background_tasks also accepts a timeout, turning a slow subagent into an interim status update rather than a blocked turn.

Every background delegation returns a taskId that you can pass to continue_task. An interrupted subagent picks up from its last saved progress, while a completed one accepts follow-up instructions in its existing session.

Background runs are tasks any process can pick up

RunDetached starts an agent in the background and hands you a task. The task is just a snapshot ID, so store it anywhere and rehydrate it later:

task, _ := agent.RunDetached(ctx, &aix.AgentInput{Message: msg})
id := task.SnapshotID() // save it

// Any process, any time later:
snap, _ := agent.Task(id).Wait(ctx) // or Poll for one read, Abort to stop

For remote clients, POST /agents/{name}/waitForSnapshot provides the same blocking behavior over HTTP, resolving when the background task finishes instead of using a client-side polling loop. You can also use AgentHandle to invoke agents by name without declaring static type parameters:

h := genkitx.LookupAgent(g, "researcher")
out, _ := h.RunText(ctx, "Summarize the latest Go release.")

Stream interactive UI with A2UI

The new preview a2ui plugin brings A2UI support to Genkit Go. Your agent streams interactive surfaces, and the client renders them as they arrive. Giving your agent A2UI capabilities is as simple as adding a single middleware:

import a2uix "github.com/firebase/genkit/go/plugins/a2ui/exp"

resp, _ := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithSystem("Render UI when it is clearer than prose."),
    ai.WithPrompt("show me the weather in Tokyo"),
    ai.WithUse(&a2uix.Surfaces{}), // bundled basic catalog
)

// Envelopes ride as data parts. Hand them to any A2UI renderer.
envelopes := a2uix.EnvelopesFromParts(resp.Message.Content)

The envelopes are byte-compatible with the JS and Dart plugins and the @a2ui/* renderers, so our A2UI web demo works unchanged against a Go backend sample. Bring your own components with LoadCatalog.

Also in this release

Provider blockage error handling. GenerateData and other typed helpers return ai.ErrGenerationBlocked when a provider blocks a response, making policy refusals distinct from validation failures.
Context cache composition. Gemini explicit context caching no longer sends the cached prefix inline or creates a new cache on every request. WithCacheTTL and WithCacheName now compose.
Developer UI enhancements. The background-task panel works with Go background models, middleware config fields include descriptions, and each JSON-dispatched middleware call receives its own config.
Trace fidelity. Tool-loop turns record the messages they sent, reasoning parts render as one thought, and googlegenai uses a plain HTTP client by default.
New agent samples. The basic-agents sample adds an incident commander built on background delegation, and basic-middleware/a2ui serves the A2UI web demo.

Get started

We can’t wait to see what you build with Genkit Go 1.13. Check out the Genkit Go docs, run the updated samples, or read the full release notes.

Genkit Python 0.11: Video generation, typed model options, and unified error handling

Wed, 02 Sep 2026 12:00:00 GMT

Genkit Python 0.11 brings video generation, improved DX for model configuration, unified error handling across providers, and structured debug logs in the Developer UI. Video models now run as background operations you can poll or cancel, family constructors provide autocomplete for model options directly in your editor, and provider HTTP errors normalize into a single GenkitError with classified statuses. Calls to generate also preserve intermediate message history when a tool loop ends early, allowing you to resume execution without repeating completed tool calls.

To install or update to the new version, run the following command in your terminal:

uv add genkit genkit-google-genai

Generate video content

Genkit Python now supports video generation with models like Veo. Because rendering high-resolution video takes time, generation runs as an asynchronous background operation using generate_operation, returning an Operation you can poll until the video is ready:

import asyncio
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()])

operation = await ai.generate_operation(
    model=GoogleAI.veo_model('veo-3.1-fast-generate-preview'),
    prompt='A paper airplane gliding through a bright classroom',
)

while not operation.done:
    await asyncio.sleep(2)
    operation = await ai.check_operation(operation)

print(operation.output.media[0].url)

You can also test video models interactively in the Developer UI. Submitting a prompt from the model runner tracks the background generation and plays the finished video directly in the browser:

Configure models with strongly typed options

Genkit Python now provides strongly typed model references. Family constructors like GoogleAI.gemini_model, Anthropic.claude_model, and OpenAI.gpt_model bind each model directly to its supported configuration schema:

from genkit import Genkit
from genkit_anthropic import Anthropic, AnthropicConfig
from genkit_google_genai import GeminiConfigSchema, GoogleAI
from genkit_openai import OpenAI, OpenAIConfig

ai = Genkit(plugins=[GoogleAI(), Anthropic(), OpenAI()])

# Pass typed model references and provider configs directly inline
res1 = await ai.generate(
    model=GoogleAI.gemini_model(
        'gemini-flash-latest',
        config=GeminiConfigSchema(temperature=0.2),
    ),
    prompt='Say hi in one word.',
)

res2 = await ai.generate(
    model=Anthropic.claude_model(
        'claude-sonnet-4-6',
        config=AnthropicConfig(max_output_tokens=1024),
    ),
    prompt='Say hi in one word.',
)

res3 = await ai.generate(
    model=OpenAI.gpt_model(
        'gpt-5.2',
        config=OpenAIConfig(temperature=0.2),
    ),
    prompt='Say hi in one word.',
)

Typed references provide autocomplete, inline parameter hints, and type safety in your editor, helping you discover supported options and catch provider mismatches before running your code.

Unified error handling across model providers

Genkit Python now normalizes provider exceptions into a unified GenkitError. A single error handling block gives you consistent status codes across Gemini, Anthropic, and OpenAI:

from genkit import Genkit, GenkitError
from genkit_google_genai import GoogleAI
from genkit_middleware import Retry

ai = Genkit(plugins=[GoogleAI()])

try:
    response = await ai.generate(
        model=GoogleAI.gemini_model('gemini-flash-latest'),
        prompt='Draft a travel itinerary for a weekend in Kyoto.',
        use=[Retry()],
    )
    print(response.text)
except GenkitError as err:
    # Unified exception type across Gemini, Claude, and GPT
    print(err.status, err.original_message)
    if err.status == 'RESOURCE_EXHAUSTED' and err.response_metadata:
        print('Retry after', err.response_metadata.get('retry_after_ms'), 'ms')

Standardized status codes make it straightforward to inspect rate limits, configure retries, and build consistent error recovery across every provider.

Debug logs in the Developer UI

When iterating on your AI application locally, calls to generate now stream structured debug logs directly into the Developer UI trace viewer.

Execution spans capture lifecycle milestones like model calls, tool executions, and middleware behavior in the Logs panel. This gives you a detailed diagnostic trail right beside your trace spans while keeping your terminal output clean.

Resume incomplete generate calls

When a multi-turn tool loop ends early due to errors or turn limits, generate now returns the intermediate state instead of raising an exception. This lets you inspect progress and resume from where you left off, without repeating completed tool calls:

from pydantic import BaseModel
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(
    plugins=[GoogleAI()],
    model=GoogleAI.gemini_model('gemini-flash-latest'),
)

class TripQuery(BaseModel):
    destination: str

@ai.tool()
async def search_flights(query: TripQuery) -> list[str]:
    """Find available flights to a destination."""
    return [f'Flight 101 to {query.destination}']

@ai.tool()
async def book_hotel(query: TripQuery) -> str:
    """Reserve hotel accommodations in a destination."""
    return f'Hotel in {query.destination} reserved'

response = await ai.generate(
    prompt='Search flights to Kyoto, then reserve a hotel.',
    tools=[search_flights, book_hotel],
)

if response.finish_reason in ('failed', 'aborted'):
    # Completed tool rounds are preserved in response.messages.
    # Resume the turn without repeating earlier tool calls:
    response = await ai.generate(
        messages=response.messages,
        tools=[search_flights, book_hotel],
    )

print(response.text)

The messages history preserves completed tool rounds and omits pending requests, so you can pass messages directly back into generate to resume execution without duplicate calls.

Also in this release

OpenAI streaming token usage. Streaming completions from OpenAI now request and populate token consumption metrics through include_usage.
Whisper translation routing. Whisper audio models now accept config={'translate': True}, routing requests to the translations endpoint.

Get started

Upgrade to Genkit Python 0.11 today to take advantage of video generation, improved model configuration, and resumable generation. Explore the Genkit Python documentation, experiment with the Python samples, or review the complete v0.11.0 release notes.

Genkit Agents come to Dart: full-stack conversational AI for Flutter

Wed, 15 Jul 2026 12:00:00 GMT

Genkit is an open-source framework for building full-stack, AI-powered and agentic applications for any platform with support for Dart, TypeScript, Go, and Python. Some of the most compelling AI features are conversational: a support assistant that remembers the ticket, a copilot that works across several turns. Each needs more than a single generate() call. Building one means wiring up message history, the tool loop, streaming, persistence, and a client protocol by hand, plumbing that repeats on every project and has little to do with what makes your app distinct.

The Agents API is now available in Genkit Dart. It packages all of that behind one interface. You define an agent on the server, then drive it with the same chat() API whether it runs in process or behind an HTTP endpoint. And because that endpoint speaks one shared wire protocol, a Flutter app can talk to agents written in Dart, JS, Go, or Python without changing a line of client code.

For Flutter developers this closes the loop: the same language, the same types, and the same chat() surface run on both the server and the client.

Define an agent

An agent needs a name and a system prompt to start. From there you add tools, state, and a session store as the feature grows. Here is a weather agent with a single tool and a file-backed session store so conversations survive restarts:

import 'package:genkit/genkit.dart';
import 'package:genkit/experimental.dart';
import 'package:genkit/experimental_io.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';

final ai = Genkit(
  plugins: [googleAI()],
  model: googleAI.gemini('gemini-flash-latest'),
);

final getWeather = ai.defineTool(
  name: 'getWeather',
  description: 'Get the current weather for a given location.',
  inputSchema: GetWeatherInput.$schema,
  outputSchema: GetWeatherOutput.$schema,
  fn: (input, _) async => GetWeatherOutput(
    weather: 'Sunny in ${input.location}',
    temperature: '71F',
  ),
);

final weatherAgent = ai.defineAgent(
  name: 'weatherAgent',
  system:
      'You are an assistant helping with weather information. Use the '
      'getWeather tool.',
  tools: [getWeather],
  store: FileSessionStore('.sessions'), // server-managed state
);

The same agent object handles a one-shot reply, a streamed turn, a paused tool call, and a multi-turn conversation. You call it in process just like you would over HTTP:

final chat = weatherAgent.chat();
final turn = chat.sendStream(text: 'What is the weather in London?');
await for (final chunk in turn.stream) {
  stdout.write(chunk.text);
}
final res = await turn.response;

A chat carries its snapshotId/state forward across turns automatically, so multi-turn is just calling send again. Adding a store makes the agent server-managed: the server persists messages, custom state, and artifacts as snapshots, and clients continue by sending back a session ID. Leave the store off and the agent is client-managed, so the client owns the state blob and passes it back each turn.

Serve it over HTTP

Every agent is already a servable action, so putting one behind an HTTP endpoint takes only a few lines with genkit_shelf. You mount the agent’s turn action alongside its snapshot and abort companions:

import 'package:genkit_shelf/genkit_shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:shelf/shelf_io.dart' as io;

final router = Router();

router.post('/api/weatherAgent', shelfHandler(weatherAgent.action));
router.post(
  '/api/weatherAgent/getSnapshot',
  shelfHandler(weatherAgent.getSnapshotDataAction),
);
router.post(
  '/api/weatherAgent/abort',
  shelfHandler(weatherAgent.abortAgentAction),
);

await io.serve(router.call, InternetAddress.anyIPv4, 8080);

Each agent gets a turn endpoint that handles normal and streaming turns, plus a getSnapshot companion when it has a session store and an abort companion for detached background work. That same wire protocol is what the client below speaks.

The Flutter payoff: `remoteAgent` on the client

The piece that ties your server and your Flutter app together is the remote client. remoteAgent() from package:genkit/experimental_client.dart returns a handle with the same chat() interface as a local agent, so the code that drives an agent in your backend tests is the code that drives it from your app. There is no separate request and response protocol to design, and no streaming format to invent.

import 'package:genkit/experimental_client.dart';

final weather = remoteAgent(
  url: 'http://localhost:8080/api/weatherAgent',
  getSnapshotUrl: 'http://localhost:8080/api/weatherAgent/getSnapshot',
  abortUrl: 'http://localhost:8080/api/weatherAgent/abort',
);

final chat = weather.chat();
final turn = chat.sendStream(text: 'Weather in Tokyo?');
await for (final chunk in turn.stream) {
  stdout.write(chunk.text);
}
final res = await turn.response;

Streaming is built into the same interface: sendStream() gives you a chunk stream and a final response, and each chunk can carry text, custom state, or an artifact as it is produced. Here is a compact Flutter widget that streams a turn straight into the UI:

class WeatherChat extends StatefulWidget {
  const WeatherChat({super.key});

  @override
  State<WeatherChat> createState() => _WeatherChatState();
}

class _WeatherChatState extends State<WeatherChat> {
  final _agent = remoteAgent(
    url: 'https://your-backend.example.com/api/weatherAgent',
  );
  late final _chat = _agent.chat();
  String _text = '';

  Future<void> _ask(String prompt) async {
    setState(() => _text = '');
    final turn = _chat.sendStream(text: prompt);
    await for (final chunk in turn.stream) {
      if (chunk.text.isNotEmpty) {
        setState(() => _text = chunk.accumulatedText);
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Expanded(child: SingleChildScrollView(child: Text(_text))),
        TextField(
          onSubmitted: _ask,
          decoration: const InputDecoration(hintText: 'Ask about the weather'),
        ),
      ],
    );
  }
}

The client resolves dynamic auth headers per request, applies streamed state patches, and continues the next turn with a session ID, a snapshot ID, or client-managed state, whichever your agent uses. Because remoteAgent lives in the browser-safe package:genkit/experimental_client.dart, the same code runs on Flutter mobile, desktop, and web.

One protocol, any backend, any client

Here is the part that matters for real teams: the agent wire protocol is shared across every Genkit language. A remoteAgent in your Flutter app does not know or care what language its server is written in. It talks to agents written in Dart, JS, Go, or Python over the exact same HTTP interface.

That means your Flutter frontend can:

Connect to a Dart backend so your whole stack is one language.
Reach an existing JS, Go, or Python agent your team already runs, with no bespoke client.
Switch or mix backends later without rewriting the app. The client code is identical.

The frontend code above stays the same in every case. Only the URL changes.

And it runs both ways: because the protocol is symmetric, an agent you write in Dart is reachable by a remoteAgent in JS, Go, or Python just as easily. A Dart backend can power a web, mobile, or server client written in another language, so Dart is a first-class choice for the server side even when your frontend is not Dart.

Beyond chat

The Agents API in Dart carries the full feature set, not just streaming chat:

Custom state. Tools mutate typed session state through ai.currentSession(), and Genkit streams the changes to the client as customPatch chunks so your UI stays live mid-turn. Great for a task list, workflow status, or any structured value that drives the next turn.
Human in the loop. A tool can interrupt to pause a turn before a payment, a deployment, or any action you do not want to run automatically. The client approves, rejects, or supplies the missing value, then resumes the same chat.
Custom agents. defineCustomAgent gives you full control of the turn loop for multi-step orchestration, multiple models, and manual message and state handling, all while streaming status to the client.
Work that outlives the request. With server-managed state, a client can detach a long turn, close the app, and reconnect later by snapshot ID while the agent keeps working on the server.

Get started

Genkit Agents bring the repeated plumbing of conversational, full-stack AI to Dart and Flutter as something you configure rather than rebuild. Define an agent on the server, give it a store when you want persistence, and drive it from your Flutter app with the same chat() interface through remoteAgent().

Read the docs: Dive into the Agents documentation to see everything you can do.
New to Genkit Dart? Start with the quickstart guide.
Join the community: Ask questions and chat with the team on our Discord server.
Stay updated: Follow us on X and LinkedIn.
Give feedback: Open an issue on the GitHub repository to report bugs or request features.

We can’t wait to see what you build. Happy coding! 🚀

Dotprompt comes to Genkit Dart: Richer prompt templating and management

Fri, 19 Jun 2026 12:00:00 GMT

Prompt engineering is an iterative process. The model, its parameters, and the prompt text all shape the output together, and getting them right takes many rounds of tuning. As a prompt grows in complexity, it helps to treat that whole bundle as an artifact you can edit, version, and test on its own. That is where Dotrpompt can help!

Genkit Dart 0.14.0 brings Dotprompt to Dart and Flutter developers. Simple prompts are often fine inline, and Genkit still supports that. When a prompt does more work, Dotprompt lets you move it into a .prompt file that lives alongside your app. You define the prompt there, iterate on it in the Developer UI, and run it from Dart by name.

A prompt in a file

A .prompt file is YAML front matter, holding the model and its config, followed by a Handlebars template. Drop this into your prompts/ directory as greeting.prompt:

---
model: googleai/gemini-flash-latest
config:
  temperature: 0.7
input:
  schema:
    name: string, the person to greet
    style: string, the greeting style (e.g. cheerful, casual, pirate)
---
{{role "system"}}
You are a friendly greeter. Greet the user warmly.
{{role "user"}}
Say hello to {{name}} in a {{style}} way.

Then load and run it from your app. By default Genkit looks for prompts in ./prompts:

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';

void main() async {
  final ai = Genkit(plugins: [googleAI()]);

  final greeting = await ai.prompt('greeting');
  final response = await greeting({'name': 'Ada', 'style': 'cheerful'});
  print(response.text);
}

For a prompt like this, none of the prose lives in your code. The model and temperature sit right next to the text they shape, and your application asks for the prompt by name and stays out of the tuning loop.

When to give a prompt its own file

Not every prompt needs one. A single-line system prompt can stay in your Dart. Reach for a .prompt file once a prompt does enough work to earn the benefits below, which usually means complex or highly dynamic templating, or text that a separate subject-matter expert needs to review and edit.

Independent versioning: Prompt changes land as prompt diffs you can review and revert on their own, without untangling them from application logic. The history shows exactly how the wording, model, and config evolved.
Real templating: Handlebars helpers, partials, and conditionals express complex, dynamic prompts cleanly, so you can drop the brittle string concatenation in Dart.
Accessible for non-developers: A subject-matter expert who doesn’t work on the code can read the plain YAML and template and adjust the prompt with more confidence.
An executable, testable unit: The model, config, input and output schemas, and template all travel together as one runnable artifact. You render it, run it, and assert on its output directly, rather than reassembling the pieces at every call site.
Fast iteration: Load prompts in the Developer UI, where you run it against custom input, compare against variants, and view detailed execution traces for rapid iteration.

What shipped

This release brings the full Dotprompt feature set to Dart:

.prompt files with YAML front matter, Handlebars templates, and the {{role}} and {{media}} helpers for multi-message and multimodal prompts.
Structured I/O via input and output schemas, including Picoschema and schemas defined in code with schemantic.
Streaming with prompt.stream(), plus render() to inspect the final messages without calling the model.
Variants for side-by-side experimentation. Add a greeting.formal.prompt file and load it with await ai.prompt('greeting', variant: 'formal').
Partials for reusable snippets. A file like _signature.prompt can be included in any prompt with {{> signature}}.

Prompt templates in code

Prefer to keep prompts in code but still want the templating benefits? Define a strongly-typed input schema with schemantic:

@Schema()
abstract class $JokeInput {
  @Field(description: 'The joke topic (e.g. programming, cats, cooking)')
  String get topic;

  @Field(description: 'The joke style (e.g. punny, dry, dad)')
  String get style;
}

Then definePrompt() takes the same metadata as a .prompt file with a Handlebars template and the generated schema:

final jokePrompt = ai.definePrompt(
  name: 'joke',
  model: modelRef('googleai/gemini-flash-latest'),
  config: {'temperature': 0.9},
  inputSchema: JokeInput.$schema,
  system: 'You are a witty comedian. Keep jokes family-friendly.',
  prompt: 'Tell me a {{style}} joke about {{topic}}.',
);

final response = await jokePrompt(JokeInput(topic: 'cats', style: 'punny'));
print(response.text);

And when you need to build messages programmatically, defineCustomPrompt() lets you return a GenerateActionOptions describing the request yourself.

Iterate in the Developer UI

Every .prompt file loads straight into the Genkit Developer UI. There you can edit parameters, run them against live input, and compare variants side by side in traces.

Start the UI alongside your app:

genkit start -- dart run

Get started

Update to Genkit Dart 0.14.0 and start moving your prompts into .prompt files today.

Read the docs: Dive into the Dotprompt documentation to see everything you can do.
New to Genkit Dart? Start with the quickstart guide.
Join the community: Ask questions and chat with the team on our Discord server.
Stay updated: Follow us on X and LinkedIn.
Give feedback: Open an issue on the GitHub repository to report bugs or request features.

We can’t wait to see what you build. Happy prompting! 🚀

Is it thinking or is it broken? Building transparent AI chat UIs with Genkit

Wed, 17 Jun 2026 12:00:00 GMT

One of the worst user experiences imaginable is that your users are convinced your app is broken while your app is working correctly. This is even more apparent with AI powered apps since processing takes some time to occur with AI models. Your user sends a chat message and then they are stuck waiting on a response with no insight into whether or not the app is doing anything. In this post, we are going to break down how to give your users insights into your agents’ thought process to make sure your users aren’t left hanging.

Streaming thoughts

Genkit has the capability through server sent events to emit a stream of data to clients connecting to your agent. Some of the things that can be streamed include the regular text responses but most models now include things like thinking to improve their reasoning and responses to users. The following is an example of the experience you can create with Genkit that visualizes your thinking process for your model.

Agent Streaming Session Demo

Hello! I am your simulated Genkit AI instance built with Gemini Flash. Ask me a question or try a suggestion below, and I'll stream my step-by-step thinking process alongside my final response!

Suggestions:

This not only gives you insight into what the agent is doing but also improves the output of the response. By using thinking, we can improve our agents’ responses and also provide a better user experience. Below is a Genkit code snippet on how to extract a thought from an agent and then by using a server sent events stream that thought process down to the user.

// 1. Generate a stream with thinking config enabled
const { stream, response } = await ai.generateStream({
  model: googleAI.model('gemini-flash-latest'),
  prompt: 'Why is Genkit so cool?',
  config: {
    thinkingConfig: {
      includeThoughts: true,
      thinkingLevel: 'MEDIUM',
    },
  },
});

// 2. Consume the stream and separate reasoning from the final response
for await (const chunk of stream) {
  // Extract reasoning (thinking process)
  const thoughtText = chunk.reasoning || '';
  if (thoughtText) {
    sendChunk({ type: 'thought', content: thoughtText });
  }

  // Extract standard text response
  const text = chunk.text;
  if (text) {
    sendChunk({ type: 'text', content: text });
  }
}

After looking at this sample, you may be wondering what sendChunk is returning. This is the Output Schema that we defined for our Genkit flow. In this example, it looks something like this:

const StreamChunkSchema = z.object({
  messageId: z.string(),
  type: z.enum(['thought', 'text']),
  content: z.string(),
  currentStep: z.string().optional(),
});

Rendering the thoughts in the chat window

By having the thoughts being streamed from the server, we can now put together responses that our client would receive to give some clarity to our users. We designed a React component that is a thought box that uses CSS to show an animation as new thoughts are streamed down. We also provided an option to then receive those thoughts and store all of them in a smaller text box that is collapsible so users can inspect the full thought contents as they are received giving the user a choice to see what exactly the model is doing or to continue to recieve high level updates.

import React, { useState } from 'react';

interface ThoughtBoxProps {
  content: string;    // The full accumulated thought content
  stepName?: string;  // The current step description (e.g. "Analyzing input")
}

export const ThoughtBox: React.FC<ThoughtBoxProps> = ({ content, stepName }) => {
  const [isOpen, setIsOpen] = useState(false);
  const activeStep = stepName || 'Thinking';

  return (
    <div className="message thought-message">
      <div className="thought-box">
        {/* Animated header showing the current step */}
        <div className="thought-header">
          <div key={`indicator-${activeStep}`} className="thought-indicator indicator-animate" />
          <div key={`label-${activeStep}`} className="thought-step-label step-animate">
            Thinking: {activeStep}
          </div>
        </div>

        {/* Collapsible details wrapper for the full thought content */}
        <details
          className="thought-details"
          onToggle={(e) => setIsOpen(e.currentTarget.open)}
        >
          <summary className="thought-summary">
            <span className="summary-text">
              {isOpen ? 'Hide Full Reasoning' : 'Show Full Reasoning'}
            </span>
          </summary>
          <div className="thought-body">{content}</div>
        </details>
      </div>
    </div>
  );
};

With this component, we can easily add it to other apps that are not strictly chat based apps but other apps that might want to have a thought component rendered while the models are thinking.

Putting it all together

Using a small React component with our Genkit flow allows us to keep the user informed of what is going on while our models are thinking. This makes it appear that the model is working and processing information keeping the user informed and limiting their impression that the app has stalled or is broken.

If you want to try out the React component and Genkit streaming server-sent events yourself, you can check out the streaming thoughts sample in our samples repository.

Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps

Thu, 14 May 2026 12:00:00 GMT

Genkit is an open-source framework for building full-stack, AI-powered and agentic applications for any platform with support for TypeScript, Go, Dart, and Python. Building a production-ready agentic applications and AI features requires more than powerful models and careful prompting. You might need retries and fallbacks for maximum reliability, human approval before destructive tool calls, and observability across every layer.

Genkit solves this with middleware: composable hooks that intercept generation calls, including the tool execution loop, and inject custom behaviors. The middleware system is available today in TypeScript, Go, Dart, and Python (genkit-middleware — see the middleware docs).

How Genkit middleware works

Every generate() call in Genkit runs a tool loop: the model produces output, any requested tools execute, the results feed back into a new model call, and the cycle repeats until the model is done. Middleware hooks attach at three layers of this loop:

Hook	When it runs	Typical use
Generate	Once per tool-loop iteration	Context injection, message rewriting, conversation-level logic
Model	Once per model API call	Retry, fallback, caching, latency logging
Tool	Once per tool execution	Human-in-the-loop, sandboxing, per-tool logging

Pre-built middleware

Genkit offers several pre-built middleware solutions for common use-cases. Here’s what’s available today:

1. Retry

Automatically retries failed model API calls on transient errors (RESOURCE_EXHAUSTED, UNAVAILABLE, etc.) using exponential backoff with jitter. Only the model call is retried; the surrounding tool loop is not replayed.

const response = await ai.generate({
  model: googleAI.model('gemini-flash-latest'),
  prompt: 'Summarize the quarterly earnings report.',
  use: [
    retry({ maxRetries: 3, initialDelayMs: 1000, backoffFactor: 2 }),
  ],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("Summarize the quarterly earnings report."),
    ai.WithUse(&middleware.Retry{
        MaxRetries:     3,
        InitialDelayMs: 1000,
        BackoffFactor:  2,
    }),
)

final response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'Summarize the quarterly earnings report.',
  use: [
    retry(maxRetries: 3, initialDelayMs: 1000, backoffFactor: 2),
  ],
);

2. Fallback

Switches to an alternative model when the primary model fails on a specified set of error codes. Useful for falling back to a smaller, faster model, or a different provider entirely, when your primary model exceeds its quota.

TypeScript
Go

const response = await ai.generate({
  model: googleAI.model('gemini-pro-latest'),
  prompt: 'Analyze this complex document...',
  use: [
    fallback({
      models: [googleAI.model('gemini-flash-latest')],
      statuses: ['RESOURCE_EXHAUSTED'],
    }),
  ],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-pro-latest"),
    ai.WithPrompt("Analyze this complex document..."),
    ai.WithUse(&middleware.Fallback{
        Models: []ai.ModelRef{
            googlegenai.ModelRef("googleai/gemini-flash-latest", nil),
        },
        Statuses: []core.StatusName{core.RESOURCE_EXHAUSTED},
    }),
)

Fallback isn’t available in the Dart SDK yet.

3. Tool approval

Restricts tool execution to an allow-list. Any tool not on the list triggers an interrupt, enabling human-in-the-loop confirmation before the action proceeds.

// 1. Initial attempt — an empty allow-list interrupts every tool call.
const response = await ai.generate({
  prompt: 'Delete the temp files',
  tools: [deleteFilesTool],
  use: [toolApproval({ approved: [] })],
});

if (response.finishReason === 'interrupted') {
  const interrupt = response.interrupts[0];

  // 2. Prompt the user for approval, then recreate the tool request.
  const approvedPart = restartTool(interrupt, { toolApproved: true });

  // 3. Resume execution with the approval.
  const resumed = await ai.generate({
    messages: response.messages,
    resume: { restart: [approvedPart] },
    use: [toolApproval({ approved: [] })],
  });
}

resp, _ := genkit.Generate(ctx, g,
    ai.WithPrompt("Delete the temp files"),
    ai.WithTools(deleteFilesTool),
    ai.WithUse(&middleware.ToolApproval{
        AllowedTools: []string{}, // empty = every tool call interrupts
    }),
)

if len(resp.Interrupts()) > 0 {
    interrupt := resp.Interrupts()[0]

    // Prompt the user for approval, then resume with the approval flag.
    approved, _ := deleteFilesTool.RestartWith(interrupt,
        ai.WithResumedMetadata[DeleteInput](map[string]any{"toolApproved": true}),
    )

    resp, err := genkit.Generate(ctx, g,
        ai.WithMessages(resp.History()...),
        ai.WithTools(deleteFilesTool),
        ai.WithToolRestarts(approved),
        ai.WithUse(&middleware.ToolApproval{}),
    )
    fmt.Println(resp.Text())
}

// 1. Initial attempt — an empty allow-list interrupts every tool call.
final response = await ai.generate(
  prompt: 'Delete the temp files',
  tools: [deleteFilesTool],
  use: [toolApproval(approved: [])],
);

if (response.finishReason == FinishReason.interrupted) {
  final part = response.interrupts.first;

  // 2. Ask the user for approval, then resume execution.
  final resumed = await ai.generate(
    messages: response.messages,
    resume: [InterruptResponse(part, true)],
    use: [toolApproval(approved: [])],
  );
}

4. Skills

Scans a directory for SKILL.md files and injects their content into the system prompt. Also exposes a use_skill tool so the model can load specific skills on demand.

const response = await ai.generate({
  prompt: 'How do I deploy this service?',
  use: [skills({ skillPaths: ['./skills'] })],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("How do I deploy this service?"),
    ai.WithUse(&middleware.Skills{SkillPaths: []string{"./skills"}}),
)

final response = await ai.generate(
  prompt: 'How do I deploy this service?',
  use: [skills(skillPaths: ['./skills'])],
);

5. Filesystem

Gives the model scoped access to the local filesystem through injected tools (list_files, read_file, plus write_file and edit_file when writes are enabled). Path safety is enforced so the model can never escape the root directory.

const response = await ai.generate({
  prompt: 'Create a hello world program in the workspace',
  use: [filesystem({ rootDirectory: './workspace', allowWriteAccess: true })],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Create a hello world program in the workspace"),
    ai.WithUse(&middleware.Filesystem{
        RootDir:          "./workspace",
        AllowWriteAccess: true,
    }),
)

final response = await ai.generate(
  prompt: 'Create a hello world program in the workspace',
  use: [filesystem(rootDirectory: './workspace')],
);

Building custom middleware

The pre-built middleware covers common scenarios, but the real power of the system is in writing your own. Imagine you’re building an agentic customer-support app and need to ensure the model never mentions competitor products or internal pricing data. Rather than encoding these rules in every prompt, you can enforce them deterministically with middleware.

Custom middleware follows a simple contract across all languages: provide a name and a factory that returns the hooks you want. The factory runs once per generate() invocation, and you implement only the hooks you need.

Here’s a complete, custom content filter that rejects any response containing a forbidden term:

import { generateMiddleware, z } from 'genkit';

export const contentFilter = generateMiddleware(
  {
    name: 'contentFilter',
    description: 'Rejects model responses containing forbidden terms',
    configSchema: z.object({ forbiddenTerms: z.array(z.string()) }),
  },
  ({ config }) => ({
    model: async (req, ctx, next) => {
      const resp = await next(req, ctx);
      const text = resp.text.toLowerCase();
      for (const term of config?.forbiddenTerms ?? []) {
        if (text.includes(term.toLowerCase())) {
          throw new Error(`content filter: response contains "${term}"`);
        }
      }
      return resp;
    },
  }),
);

// ContentFilter rejects model responses containing any forbidden term.
type ContentFilter struct {
    ForbiddenTerms []string `json:"forbiddenTerms"`
}

func (ContentFilter) Name() string { return "app/contentFilter" }

func (f ContentFilter) New(ctx context.Context) (*ai.Hooks, error) {
    return &ai.Hooks{
        WrapModel: func(ctx context.Context, p *ai.ModelParams, next ai.ModelNext) (*ai.ModelResponse, error) {
            resp, err := next(ctx, p)
            if err != nil {
                return nil, err
            }
            text := strings.ToLower(resp.Text())
            for _, term := range f.ForbiddenTerms {
                if strings.Contains(text, strings.ToLower(term)) {
                    return nil, fmt.Errorf("content filter: response contains %q", term)
                }
            }
            return resp, nil
        },
    }, nil
}

// Reject model responses containing any forbidden term.
class ContentFilter extends GenerateMiddleware {
  final List<String> forbiddenTerms;

  ContentFilter({this.forbiddenTerms = const []});

  @override
  Future model(ModelRequest request, dynamic ctx, dynamic next) async {
    final response = await next(request, ctx);
    final text = response.text.toLowerCase();
    for (final term in forbiddenTerms) {
      if (text.contains(term.toLowerCase())) {
        throw Exception('content filter: response contains "$term"');
      }
    }
    return response;
  }
}

Register it with defineMiddleware to expose a contentFilter() helper you can drop into a use array. See the middleware docs for the full registered pattern.

You can even compose and stack different middleware solutions. Middleware stacks left-to-right, with the first listed being the outermost wrapper:

const response = await ai.generate({
  model: googleAI.model('gemini-flash-latest'),
  prompt: 'What CRM should our customer use?',
  use: [
    retry({ maxRetries: 3 }), // outer: retries the inner stack
    contentFilter({           // inner: validates model output
      forbiddenTerms: ['CompetitorCRM', 'RivalCo', 'internal price'],
    }),
  ],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("What CRM should our customer use?"),
    ai.WithUse(
        &middleware.Retry{MaxRetries: 3},           // outer: retries the inner stack
        &ContentFilter{                              // inner: validates model output
            ForbiddenTerms: []string{"CompetitorCRM", "RivalCo", "internal price"},
        },
    ),
)

final response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'What CRM should our customer use?',
  use: [
    retry(maxRetries: 3),                 // outer: retries the inner stack
    contentFilter(forbiddenTerms: const [ // inner: validates model output
      'CompetitorCRM', 'RivalCo', 'internal price',
    ]),
  ],
);

Here Retry wraps ContentFilter, which wraps the model call. Order matters, and Genkit makes it explicit.

If you think you’ve built a middleware that will be valuable to other developers, you can publish it as a package for others to benefit from!

The Developer UI experience

You can use the Genkit Developer UI to inspect, test, and debug your application, including middleware execution. When you register middleware, it becomes visible in the Dev UI: you can inspect its configuration, trace execution through each hook layer, and test different combinations.

Get started

We’re excited for the capabilities that Genkit middleware unlocks for your apps, and we’re looking forward to seeing what custom middleware you’ll build to solve for your use-cases. Check out the middleware documentation to dive deeper, or get started with Genkit if you’re new to the framework.

Have an idea for a new pre-built middleware? File an issue. We’d love to hear what would improve your development experience!

Happy coding! 🚀

Announcing Genkit Dart: Build full-stack AI apps with Dart and Flutter

Tue, 10 Mar 2026 12:00:00 GMT

The Dart and Flutter communities have always pushed the boundaries of what’s possible across screens. You’ve shown that building high-quality, multi-platform applications doesn’t require compromising on developer experience. Now we’re bringing the same “write once, run anywhere” philosophy to AI-powered features and applications.

We are thrilled to announce the preview launch of Genkit Dart, an open-source AI framework for Dart and Flutter developers. Already available for TypeScript, Go, and Python, Genkit now empowers you to build high-quality, full-stack, AI-powered applications for any platform.

Why choose Genkit Dart?

Genkit Dart provides you with the following capabilities:

Model-agnostic API: Supports Google, Anthropic, OpenAI, and OpenAI API-compatible models out-of-the-box. You’re never locked into a single provider.
Type safety: Uses Dart’s strong type system with the schemantic package to generate strongly typed data and create type-safe AI flows.
Run code anywhere: Write your AI logic once and run it as a backend service or directly inside your Flutter app.
Developer UI: Includes a localhost web UI where you can test prompts, view traces, and debug your flows.
Complete AI toolkit: Provides everything you need to build high-quality AI features, including structured output, tools, multi-step flows, observability, and more.

Model-agnostic API

Genkit is designed to support any LLM provider, with out-of-the-box support for Google, Anthropic, OpenAI, and OpenAI API-compatible models in this release. This lets you switch between providers with minimal code changes.

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:genkit_anthropic/genkit_anthropic.dart';

void main() async {
  // Initialize Genkit with plugins
  final ai = Genkit(plugins: [
    googleAI(),
    anthropic(),
  ]);

  // Call Google Gemini
  final geminiResponse = await ai.generate(
    model: googleAI.gemini('gemini-3.1-pro-preview'),
    prompt: 'Hello from Gemini',
  );

  // Call Anthropic Claude
  final claudeResponse = await ai.generate(
    model: anthropic.model('claude-opus-4.6'),
    prompt: 'Hello from Claude',
  );
}

Type-safe AI flows

Genkit lets you wrap your AI logic into testable, observable, deployable functions called flows.

Here is an example of a Travel Planner flow using strongly-typed input and output schemas, with tool calling:

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:schemantic/schemantic.dart';

part 'travel_flow.g.dart';

// Define flow input schema with schemantic
@Schema()
abstract class $TripRequest {
  String get destination;
  int get days;
}

// Define tool input schema
@Schema()
abstract class $WeatherRequest {
  @Field(description: 'The city name')
  String get city;
}

void main() async {
  // Initialize Genkit and register the Google AI plugin
  final ai = Genkit(plugins: [googleAI()]);

  // Define a tool the model can invoke to fetch live data
  ai.defineTool(
    name: 'fetchWeather',
    description: 'Retrieves the current weather forecast for a given city',
    inputSchema: WeatherRequest.$schema,
    fn: (request, _) async => request.city.toLowerCase() == 'seattle' ? 'Rainy' : 'Sunny',
  );

  // Construct a strongly-typed, observable flow
  final tripPlannerFlow = ai.defineFlow(
    name: 'planTrip',
    inputSchema: TripRequest.$schema,
    outputSchema: .string(),
    fn: (request, _) async {
      // Generate content using the model and tool
      final response = await ai.generate(
        model: googleAI.gemini('gemini-3.1-pro-preview'),
        prompt: 'Build a ${request.days}-day travel itinerary for ${request.destination}. '
                'Make sure to check the weather forecast first to suggest appropriate activities.',
        toolNames: ['fetchWeather'],
      );

      return response.text;
    },
  );

  // Run the flow
  final itinerary = await tripPlannerFlow(
    TripRequest(destination: 'Seattle', days: 3)
  );
  print(itinerary);
}

When you’re ready, you can easily expose your flow as an API using the genkit_shelf package and deploy it to any platform that supports Dart.

import 'package:genkit_shelf/genkit_shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:shelf/shelf_io.dart' as io;

void main() async {
  // ... initialize Genkit and define tripPlannerFlow ...

  final router = Router()
    ..post(
      '/api/planTrip',
      shelfHandler(tripPlannerFlow),
    );

  await io.serve(router.call, 'localhost', 8080);
}

Run anywhere Dart runs

Most complex AI logic runs on a server. However, because Dart works on both the frontend and backend, Genkit lets you easily move your AI code between your server and your Flutter app.

Here are a few ways you can build with Genkit Dart:

1. Entirely in Flutter for prototyping

You can write all of your Genkit logic, including model calls, directly in your Flutter app. This is great for prototypes or apps where users provide their own API keys and prompts aren’t private.

Warning: You should never publish an app with your API key embedded in the source code as it can be extracted and used by others.

2. Call backend flows from Flutter

When your prompts are sensitive or your AI logic is complex, you can move the entire flow to your backend. Your Flutter app can then call this flow by defining it as a “remote action”. Since the backend and frontend are both in Dart, they can share the same schemas for end-to-end type safety.

Here is an example showing how to call the Trip Planner backend flow we defined earlier from your Flutter app:

import 'package:genkit/client.dart';
import 'package:my_shared_models/models.dart'; // Shared schema

final tripPlannerFlow = defineRemoteAction(
  url: 'https://your-server.com/api/planTrip',
  inputSchema: TripRequest.$schema,
  outputSchema: .string(),
);

final itinerary = await tripPlannerFlow(
  input: TripRequest(destination: 'Tokyo', days: 5),
);

3. In Flutter with remote models

To secure your API keys while keeping the core AI logic in your Flutter app, you can create a small Genkit backend that proxies requests to the model provider with custom authorization logic. The models exposed through this backend are remote models.

import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:genkit_shelf/genkit_shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:shelf/shelf_io.dart' as io;

// Backend securely proxies requests to the model
void main() async {
  final geminiApi = googleAI();
  final targetModel = geminiApi.model('gemini-3.1-flash-lite-preview');
  final router = Router()
    ..post(
      '/api/gemini-model',
      shelfHandler(
        targetModel,
        // Insert custom authorization logic here
        contextProvider: (req) async => {'customAuth': true},
      ),
    );
  await io.serve(router.call, 'localhost', 8080);
}

In your Flutter app, use the remote model instead of a direct model plugin, passing any headers your server needs. This saves you from exposing your API keys and gives you more control over request authorization.

import 'package:genkit/genkit.dart';

// Flutter app communicates with the proxy server
final ai = Genkit();
final secureModel = ai.defineRemoteModel(
  name: 'secureModel',
  url: 'https://api.yourdomain.com/api/gemini-model',
  headers: (context) => {'Authorization': 'Bearer ${fetchSessionToken()}'},
);
final response = await ai.generate(model: secureModel, prompt: 'Write me a poem.');

Powerful tools for AI development

Building high-quality AI applications requires thorough testing and continuous iteration to achieve reliable results. To help with this, Genkit provides a powerful local Developer UI.

You can start the Developer UI alongside your code by running your app with the Genkit CLI:

genkit start -- dart run bin/server.dart

Here is a look at testing a more advanced version of our Trip Planner flow in the Developer UI:

AI coding assistance

For the best experience using Genkit Dart with AI coding tools like Antigravity, Gemini CLI, or Claude Code, install the Genkit Dart agent skill. This gives your AI assistant the knowledge to accurately write and debug your AI features.

Add the skill to your project:

npx skills add genkit-ai/skills

Learn more

This release is an early preview. We want to work with Dart and Flutter developers to improve the framework. You can find the core packages and provider plugins on pub.dev today.

Get started: Read our quickstart guide.
Join the community: Join our Discord server to ask questions and chat with the team.
Stay updated: Follow us on X and LinkedIn.
Give feedback: Open an issue on our GitHub repository to report bugs or request features.

We can’t wait to see what you build with Genkit Dart!

Announcing Genkit Go 1.0 and enhanced AI-assisted development

Wed, 10 Sep 2025 12:00:00 GMT

We’re excited to announce the release of Genkit Go 1.0, the first stable, production-ready release of Google’s open-source AI development framework for the Go ecosystem. Along with this release, we’re also introducing the genkit init:ai-tools command to supercharge your AI-assisted development workflow.

Genkit is an open-source framework for building full-stack AI-powered applications. It provides a unified interface for multiple model providers and streamlined APIs for multimodal content, structured outputs, tool calling, retrieval-augmented generation (RAG), and agentic workflows. With Genkit Go, you can now build and deploy production-ready AI applications with the speed, safety, and reliability of Go.

TL;DR

Genkit Go is now stable and ready for production use!

Key features:

Type-safe AI flows with Go structs and JSON schema validation
Unified model interface supporting Google AI, Vertex AI, OpenAI, Ollama, and more
Tool calling, RAG, and multimodal support
Rich local development tools with a standalone CLI binary and Developer UI
AI coding assistant integration via the genkit init:ai-tools command for tools like the Gemini CLI

Ready to start coding? Check out our get started guide.

What’s new in Genkit Go 1.0

Production-ready

Genkit Go 1.0 represents our commitment to providing a stable, reliable foundation for building AI-powered applications in Go. With this release, you can deploy AI-powered applications to production with Genkit, knowing that the API is stable and well-tested.

Like Go itself, it is intended that programs written with Genkit 1.* will continue to compile and run correctly, unchanged, even as future “point” releases of Genkit arise (Genkit 1.1, Genkit 1.2, etc.).

Type-safe AI flows

One of Genkit’s most powerful features is flows: functions for AI use-cases that provide observability, easy testing, and simplified deployment. Here’s how you can define a flow in Go for generating structured recipes:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

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

// Define your data structures
type RecipeInput struct {
    Ingredient          string `json:"ingredient" jsonschema:"description=Main ingredient or cuisine type"`
    DietaryRestrictions string `json:"dietaryRestrictions,omitempty" jsonschema:"description=Any dietary restrictions"`
}

type Recipe struct {
    Title        string   `json:"title"`
    Description  string   `json:"description"`
    PrepTime     string   `json:"prepTime"`
    CookTime     string   `json:"cookTime"`
    Servings     int      `json:"servings"`
    Ingredients  []string `json:"ingredients"`
    Instructions []string `json:"instructions"`
    Tips         []string `json:"tips,omitempty"`
}

func main() {
    ctx := context.Background()

    // Initialize Genkit with plugins
    g := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-flash-latest"),
    )

    // Define a type-safe flow
    recipeFlow := genkit.DefineFlow(g, "recipeGeneratorFlow",
        func(ctx context.Context, input *RecipeInput) (*Recipe, error) {
            dietaryRestrictions := input.DietaryRestrictions
            if dietaryRestrictions == "" {
                dietaryRestrictions = "none"
            }

            prompt := fmt.Sprintf(`Create a recipe with the following requirements:
                Main ingredient: %s
                Dietary restrictions: %s`, input.Ingredient, dietaryRestrictions)

            // Generate structured data with type safety
            recipe, _, err := genkit.GenerateData[Recipe](ctx, g,
                ai.WithPrompt(prompt),
            )
            if err != nil {
                return nil, fmt.Errorf("failed to generate recipe: %w", err)
            }

            return recipe, nil
        })

    // Run the flow
    recipe, err := recipeFlow.Run(ctx, &RecipeInput{
        Ingredient:          "avocado",
        DietaryRestrictions: "vegetarian",
    })
    if err != nil {
        log.Fatalf("could not generate recipe: %v", err)
    }

    // Print the structured recipe
    recipeJSON, _ := json.MarshalIndent(recipe, "", "  ")
    fmt.Println("Sample recipe generated:")
    fmt.Println(string(recipeJSON))

    <-ctx.Done() // Used for local testing only
}

Unified model interface

Genkit Go provides a single, consistent interface for working with multiple AI model providers including Google AI, Vertex AI, OpenAI, Anthropic, and Ollama. Learn more about generating content with AI models:

// Use Google AI models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("What is the weather like today?"),
)

// Use OpenAI models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("openai/gpt-4o"),
    ai.WithPrompt("How are you today?"),
)

// Switch to Ollama for local models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("ollama/llama3"),
    ai.WithPrompt("What is the meaning of life?"),
)

Tool calling

Genkit Go makes it easy to give your AI models access to external functions and APIs. See the complete tool calling guide:

// Define a tool
type WeatherInput struct {
    Location string `json:"location" jsonschema_description:"Location to get weather for"`
}

getWeatherTool := genkit.DefineTool(g, "getWeather",
    "Gets the current weather in a given location",
    func(ctx *ai.ToolContext, input WeatherInput) (string, error) {
        // Your weather API logic here
        return fmt.Sprintf("The current weather in %s is 72°F and sunny.", input.Location), nil
    })

// Use the tool in generation
resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("What's the weather in San Francisco?"),
    ai.WithTools(getWeatherTool),
)

Easy deployment

Deploy your flows as HTTP endpoints with minimal setup. See the deployment guides for more options:

// Create HTTP handlers for your flows
mux := http.NewServeMux()
mux.HandleFunc("POST /recipeGeneratorFlow", genkit.Handler(recipeFlow))

// Start the server
log.Fatal(server.Start(ctx, "127.0.0.1:3400", mux))

Rich developer tooling

Genkit Go comes with a comprehensive set of development tools designed to make building AI applications fast and intuitive. The entire local toolchain is available through a single CLI that works seamlessly with your Go development workflow.

Standalone CLI installation

Get started quickly with our standalone CLI binary, with no other runtime installations required:

For macOS and Linux:

curl -sL cli.genkit.dev | bash

For Windows: Download directly from cli.genkit.dev.

The CLI works with Genkit applications in any supported language (JavaScript, Go, Python) and provides you with several convenient commands to rapidly test and iterate such as running and evaluating your flows.

Interactive Developer UI

The Developer UI provides a visual interface for testing and debugging your AI applications:

Test flows interactively: Run flows with different inputs and see cleanly rendered results
Debug with detailed tracing: Visualize exactly what your AI flows are doing step-by-step
Monitor performance: Track latency, token usage, and costs
Experiment with prompts: Test different prompts and model configurations

Launch the Developer UI alongside your Go application through the CLI:

genkit start -- go run .

Here’s what the experience looks like when running and inspecting the recipeGenerator flow from earlier:

Introducing `genkit init:ai-tools`

We’re also excited to introduce the genkit init:ai-tools command that revolutionizes how you work with AI assistants during development. This feature, now available for both JavaScript and Go developers, automatically configures popular AI coding assistants to work seamlessly with the Genkit framework and tooling. Learn more about AI-assisted development in Genkit.

To use it, install the Genkit CLI and run:

genkit init:ai-tools

Running the command does the following:

Detects existing AI assistant configurations and preserves your current settings
Installs the Genkit MCP server with powerful development tools:
- lookup_genkit_docs: Search Genkit documentation from genkit.dev
- list_flows: List all flows in your current Genkit app
- run_flow: Execute flows with test inputs
- get_trace: Fetch execution traces for debugging and analysis
Creates a GENKIT.md file with comprehensive language-specific instructions for AI assistants

Supported AI tools

The command has built-in support for:

Gemini CLI - Google’s CLI-based AI coding assistant
Firebase Studio - Firebase’s agentic, cloud-based development environment
Claude Code - Anthropic’s coding assistant
Cursor - AI-powered code editor

For other tools, select the “generic” option to get a GENKIT.md file you can integrate manually.

Enhanced development experience

With AI assistant integration, you can:

Ask questions about Genkit Go APIs and get accurate, up-to-date answers
Generate Go-specific Genkit code that follows best practices
Debug flows by having your AI assistant analyze traces
Test your applications with AI-generated inputs
Get help with Go-specific patterns and idiomatic code

Quick start

1. Create a new project:

mkdir my-genkit-app && cd my-genkit-app
go mod init example/my-genkit-app

2. Install Genkit and CLI:

go get github.com/firebase/genkit/go
curl -sL cli.genkit.dev | bash

3. Set up AI assistant integration:

genkit init:ai-tools

4. Create your first flow using the examples above

5. Start the Developer UI:

genkit start -- go run .

For a more detailed walkthrough, see the get started guide.

Learn more

Documentation: genkit.dev
Get started guide: Go quickstart
Go API reference: pkg.go.dev
Examples: GitHub samples
Community: Genkit Discord

Genkit Go 1.0 combines Go’s performance and reliability with Genkit’s production-ready AI framework and tooling. We can’t wait to see what you build!

Happy coding! 🚀

Genkit | Blog

Announcing Genkit Dart 1.0: Build production-ready agentic apps with Dart and Flutter

Why Genkit Dart

Use any model with one API

End-to-end type safety with flows

Run anywhere Dart runs

Test and debug with the Developer UI

Built for agentic workflows

Give models tools with human-in-the-loop interrupts

Extend generation with middleware

Manage prompts with Dotprompt

Monitor your app in production

What’s next: stateful agents and generative UI

Get started

Genkit Python 0.12: Generative UI with A2UI, typed Pydantic streaming, and Deep Research and Lyria models

Build interactive UIs with A2UI

Stream typed Pydantic models

Run Deep Research jobs and generate audio with Lyria 3

Recover cleanly from mid-turn errors

Also in this release

Get started

Genkit Dart 0.17: Resumable generate and agent loops, async subagents, and pluggable telemetry

Resume incomplete generate calls

Resume failed or aborted agent snapshots

Delegate work to background subagents

Pluggable telemetry and OpenTelemetry GenAI support

Also in this release

Get started

Genkit CLI & Dev UI 1.43: Improved human-in-the-loop testing and log viewing

Step through human-in-the-loop interrupts in the Agent Runner

Top-level Trace Logs drawer in the Developer UI

Query execution logs with genkit log:list

Also in this release

Get started

Genkit Go 1.13: Resumable generate and agent loops, async subagents, and A2UI

Keep progress across interrupted generate calls

Resume any agent turn, whether it succeeded, failed, or was aborted

Subagents run in the background

Background runs are tasks any process can pick up

Stream interactive UI with A2UI

Also in this release

Get started

Genkit Python 0.11: Video generation, typed model options, and unified error handling

Generate video content

Configure models with strongly typed options

Unified error handling across model providers

Debug logs in the Developer UI

Resume incomplete generate calls

Also in this release

Get started

Genkit Agents come to Dart: full-stack conversational AI for Flutter

Define an agent

Serve it over HTTP

The Flutter payoff: remoteAgent on the client

One protocol, any backend, any client

Beyond chat

Get started

Dotprompt comes to Genkit Dart: Richer prompt templating and management

A prompt in a file

When to give a prompt its own file

What shipped

Prompt templates in code

Iterate in the Developer UI

Get started

Is it thinking or is it broken? Building transparent AI chat UIs with Genkit

Streaming thoughts

Rendering the thoughts in the chat window

Putting it all together

Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps

How Genkit middleware works

Pre-built middleware

1. Retry

2. Fallback

3. Tool approval

4. Skills

5. Filesystem

Building custom middleware

The Developer UI experience

Get started

Announcing Genkit Dart: Build full-stack AI apps with Dart and Flutter

Query execution logs with `genkit log:list`

The Flutter payoff: `remoteAgent` on the client

Introducing `genkit init:ai-tools`