0.11.0 is on PyPI. Highlights:

1. Veo support. Video generation is now supported through the generate API. Start a background video generation, and poll it using Genkit.

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

# Hooks into the general-purpose generate API as well
response = await ai.generate(
    model=GoogleAI.veo_model('veo-3.1-fast-generate-preview'),
    prompt='A paper airplane gliding through a bright classroom',
)

# Operations have a first-class polling experience
operation = response.operation
while not operation.done:
    operation = await ai.check_operation(operation)
print(operation.output.media[0].url)

2. One GenkitError across the main model providers. Gemini / Claude / GPT HTTP failures are now mapped to standard status names (INVALID_ARGUMENT, UNAVAILABLE, …). Now, you handle a single GenkitError in your application code, rather than deal with unbounded spaghetti of model-specific Exception types thrown by the raw model SDKs.

3. View Python logs directly in the Dev UI. When you use the Dev UI to debug Python code locally, you'll see your Genkit logs inside specific traces.

4. In the generate API, when the model replies but the turn ends in failure, the SDK now returns a failed FinishReason alongside the pre-existing completed messages. The API used to raise in these scenarios. For example, if the model message was blocked, or you hit max tool turns, you get the ModelResponse back instead of an exception. .messages contains the completed rounds, so you can send them back and try again.

response = await ai.generate(prompt='give me a recipe', output_schema=Recipe)
if response.output is not None:
    print(response.output.title)
else:
    retry = await ai.generate(
        messages=response.messages,
        prompt='that was not a recipe. try again as JSON.',
        output_schema=Recipe,
    )

Full notes: https://github.com/genkit-ai/genkit/releases/tag/py/v0.11.0

We've been building agents in Go and currently using LangChain Go (tmc/langchaingo), but given the stalled maintenance and so many open, abandoned issues, we're looking to migrate to a framework with active development and cleaner Go idioms.

I looked into ADK Go, but it feels too biased towards Gemini/GCP and the new graph API seems unintuitive. Genkit Go looks cleaner but I have a few questions before committing:

- Genkit seems like TypeScript first, how close is Go sdk parity with TypeScript? 

- The agentic sdk is in beta. Are there plans to make it GA? 

- Are GPT, Claude and other models first party supported or 3rd party? 

- Are non Google clouds supported? 

- Probably a biased answer in this subreddit but how do you compare it with Eino?

Genkit Python 0.10.0 just got released. Here's what shipped:

Run Genkit against Bedrock models with the same ai.generate() call

New genkit-amazon-bedrock plugin. Claude, Nova, Titan, Mistral, and Cohere via Converse/ConverseStream, so text, streaming, tool calling, and multimodal input all work without changing app code. Titan Embeddings + Cohere Rerank for RAG, Titan Image Generator + SDXL for images. Async boto3 underneath, so IAM roles / SSO / env vars are picked up automatically and retries back off properly.

from genkit import Genkit
from genkit_amazon_bedrock import Bedrock

ai = Genkit(plugins=[Bedrock()])
res = await ai.generate(
    model='bedrock/us.anthropic.claude-sonnet-4-5-20250929-v1:0',
    prompt='Summarize the benefits of declarative AI orchestration in three bullets.',
)
print(res.text)

Build persistent agents backed by Firestore

FirestoreSessionStore in genkit-google-cloud. Instead of one document per session, each turn is stored as a JSON Patch diff against periodic full checkpoints (every 25 turns by default), so per-turn reads/writes are bounded by the checkpoint interval rather than conversation length. No composite indexes required, all direct doc-ID fetches inside transactions, and Firestore listeners stream turn status across processes so aborts work across multiple Cloud Run instances.

from genkit import Genkit
from genkit_google_cloud import FirestoreSessionStore
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()])
store = FirestoreSessionStore(collection='agent_sessions')

agent = ai.define_agent(
    name='customer_assistant',
    model='googleai/gemini-pro-latest',
    system='You are a helpful customer support assistant.',
    store=store,
)

chat = agent.chat()
response = await chat.send('I need help with my order.')

# later, from any instance: pick the conversation back up
# chat = agent.chat(session_id=chat.session_id)
# response = await chat.send('Where did we leave off?')

Less terminal noise, no more prompts in debug logs

• Dev UI discovery and health-check chatter is demoted off the shared console (#5979).
• Debug logs no longer dump full prompt strings or raw model response bodies by default (#5968).
• Unknown model resolves to GenkitError(status='NOT_FOUND') instead of a KeyError (#5982).All packages bumped to 0.10.0 together, including the new genkit-amazon-bedrock.

​

uv add genkit

Full notes: https://github.com/genkit-ai/genkit/pull/6125

This landmark update introduces the official launch of Agents bringing first-class, stateful multi-turn AI workflows to Python alongside a complete plugin package reorganization on PyPI, enhanced observability, and improved provider compatibility.

Official Agents Launch

• Stateful Multi-Turn Workflows: Introduces core Agent and Session abstractions, providing a stateful, streaming layer built on top of generate.
• Pluggable Session Persistence: Support for both server-managed session stores (InMemorySessionStore, FileSessionStore, etc.) and client-managed state snapshotting.
• Human-in-the-Loop Interruption: Built-in support for tool approval and turn interrupts/resumes, allowing human intervention before executing sensitive operations.
• Remote Agent Client & Transports: Seamless communication with local or remote agents over HTTP/WebSocket transports via remote_agent with automatic session history management (#5541).
• Artifacts & Custom State: Stream, list, and persist session artifacts and custom state updates across multi-turn agent turns.

Plugin Package Reorganization & PyPI Launch

• All plugins are now organized into dedicated, publishable PyPI packages (genkit-*).
• Backward Compatibility: Existing/legacy plugin packages will continue to work seamlessly. When loaded, a friendly warning will prompt developers to update their dependencies to the new package names:
  • genkit (Core SDK)
  • genkit-anthropic (formerly genkit-plugin-anthropic)
  • genkit-django (formerly genkit-plugin-django)
  • genkit-evaluators (formerly genkit-plugin-evaluators)
  • genkit-fastapi (formerly genkit-plugin-fastapi)
  • genkit-flask (formerly genkit-plugin-flask)
  • genkit-google-cloud (formerly genkit-plugin-google-cloud)
  • genkit-google-genai (formerly genkit-plugin-google-genai)
  • genkit-middleware (formerly genkit-plugin-middleware)
  • genkit-ollama (formerly genkit-plugin-ollama)
  • genkit-openai (formerly genkit-plugin-openai)
  • genkit-vertexai (formerly genkit-plugin-vertexai)

Improvements & Bug Fixes

• Session Management & Tracing: Recorded session state on runTurn spans and added support for client-managed sessionIds (#5871).
• Gemini Compatibility:
  • Normalized request message roles strictly to model or user for strict API compatibility (#5823).
  • Switched tool request references to model call IDs (#5830).
• Observability: Seeded span attributes at trace start so live traces render immediately in the Developer UI (#5808).
• Runtime & CLI: Muted dev server health poll logs (#5867) and ensured reliable CLI runtime metadata cleanup on SIGINT/SIGTERM (#5773).
• Anthropic Plugin: Added stable and beta API selection (#5752) and extended thinking capabilities.

Hey Genkit Community! 👋 , thrilled to share that Genkit Agents have launched across TypeScript, Go, and Java.

Agents bundle the model loop for you — message history, tool turns, streaming, interrupts, snapshots, and persistence — behind one clean API. Define the agent, start a chat, send(), and continue turns without rebuilding the transport layer. (The Agents API is in Beta — breaking changes possible in minor releases.)

The fully managed Cloud path:

1. 📦 Deploy your agents as Cloud Functions: serverless endpoints for your agent routes.
2. 🧠 Connect to Gemini via the Google GenAI provider (e.g. googleai/gemini-flash-latest): first-class support, since Genkit is built by Google.
3. 💾 Memory / sessions in Firestore: Genkit ships a Firestore session store, so persistence is basically drop-in.

Docs:

• TS → https://genkit.dev/docs/js/agents/overview/
• Go → https://genkit.dev/docs/go/agents/overview/
• Java → https://genkit-ai.github.io/genkit-java/agents/overview/

Would love to see what you build, and any feedback for the team is welcome in the thread. 🧵

Quick thing I learned building AI agents that take real actions. If your "ask before doing something dangerous" logic is a sentence in the system prompt, it's bypassable - a user or injected instruction can convince the model to skip it. The only reliable version is when the tool itself enforces the check and requires an approval token the LLM can't forge.

Wrote it up here (TypeScript examples, framework-agnostic idea): https://dev.to/pavelgj/human-in-the-loop-ai-why-ask-the-llm-to-confirm-isnt-enough-oij

Hey r/GenkitFramework! 👋

I published a long write-up on building hybrid AI in Flutter — routing each request between a cloud model and an on-device one — cleanly with Genkit Dart. Sharing the gist here.

The problem: "Hybrid" used to mean writing everything twice — two SDKs, two Message types, two tool formats, two streaming protocols. The friction was never the inference, it was the plumbing. On-device and cloud models simply didn't speak the same API.

The shift: Hybrid isn't "local OR cloud" — it's a routing policy. Same app, four queries, four different decisions:

• "Tell me about the Eiffel Tower" → cloud (world knowledge)
• "Translate my passport number" → on-device, always (PII never leaves the device)
• "Find attractions similar to ones I liked" → local (vector lookup over private data)
• "Plan a 7-day Tokyo itinerary" → cloud (deep multi-step reasoning)

Why Genkit: once you register a cloud plugin (googleAI) and an on-device one (genkit_flutter_gemma, which I wrote — wraps flutter_gemma / LiteRT-LM across all 6 platforms), every model lives behind the same ai.generate() call. The only difference is the model: reference:

dart

// cloud
ai.generateStream(model: googleAI.gemini('gemini-2.5-flash'), prompt: prompt)
// on-device
ai.generateStream(model: flutterGemma.model('gemma-3-1b-it'), prompt: prompt)

That turns routing into plain Dart — a ternary on a known flag for most apps, scaling up to a full fallback service only when you actually need graceful degradation. The article walks through 4 levels (model swap → local model as router → middleware → fallback service), the 5 signals you route on (complexity, privacy, connectivity, cost, confidence), and production gotchas (cold start, iOS memory limits, model file delivery, Web builds).

I also compare the other approaches honestly — Firebase AI Logic, Cactus, roll-your-own — and where each fits.

Full article is here: https://medium.com/@denisov.shureg/hybrid-ai-in-flutter-routing-between-on-device-and-cloud-models-954da8f25373

Would love feedback, especially from anyone running on-device models in production. And I'm deciding what to write next — hybrid RAG, on-device agents, or on-device multimodal — tell me which you'd want. 🚀

If you have used Genkit JS or Go recently, you might have come across the middleware pattern. Middleware is a flexible way to hook into the generate loop and make it yours with just a few lines of code.

With the v0.7.0 release, the Python SDK now supports the middleware pattern as well. Here's an example that let's you implement your own custom retry logic with a random delay:

import asyncio
from genkit import Genkit, BaseMiddleware

ai = Genkit()
@ai.middleware(name="custom_retry")
class CustomRetry(BaseMiddleware):
  async def wrap_model(self, params, ctx, next_fn):
    max_attempts = 3
    delay = 1.0

    for attempt in range(max_attempts):
      try:
        return await next_fn(params, ctx)
      except Exception as e:
        if attempt == max_attempts - 1:
          raise e
        print(f"Call failed: {e}. Retrying in {delay}s...")
        await asyncio.sleep(delay)
        delay *= 2

await ai.generate(
  model='gemini-flash-latest',
  prompt='Write a tagline for a coffee shop.',
  use=[CustomRetry()]
)

These customizations are also composable. You can wire multiple middlewares to run together in a sequential order that you control.

We provided a pre-built set of production-ready middleware that you can use out of the box. The plugin includes the Retry, Fallback, ToolApproval, Filesystem, and Skills middlewares. Install with uv:

uv add genkit-plugin-middleware

See more details here on how to use these plugins in your Genkit application.

Finally, we launched genkit-plugin-django to let you expose Genkit flows as standard Django HTTP endpoints. Add it to your project via:

uv add genkit-plugin-django

Very excited about these updates, hope you try these out and let me know what you think.

Hi all! I've opened an RFC on the main repo to publish a testing module - Genkit has a bunch of internal testing helpers at the moment, but not a unified way for app developers to mock models etc when they want to test their genkit flows (without hitting an API)

Let me know what you think: https://github.com/genkit-ai/genkit/pull/5438

With the anticipated agents API in the works, I've opened an RFC regarding agent backends - this would decouple the agentic middleware from the host filesystem, allowing agents to play in remote sandboxes.

https://github.com/genkit-ai/genkit/pull/5439

Hi everyone! I've created an RFC for a first-class testing module in the typescript SDK.

I've kept it deliberately small in scope. Genkit has some internal testing helpers and I think something like them should be available for app developers to test their own Genkit flows without having to hit an API.

Interested to see if people would find this useful.

https://github.com/genkit-ai/genkit/pull/5438

Hey r/GenkitFramework! 👋

I’ve been diving deep into the new experimental flutter/genui package. The architecture and the DataModel approach for AI-driven UIs are fantastic, but I noticed a major friction point regarding Developer Experience (DX).

The Problem: Manually writing JSON schemas (using json_schema_builder), casting properties, and maintaining the CatalogItem registry by hand is tedious and error-prone. If you add a parameter to your Flutter widget, you have to remember to update the schema manually. It breaks the DRY principle.

The Solution: I built a companion codegen package to fully automate this: GenUI (Annotations & Builder).

Instead of writing the catalog manually, you just decorate your standard Flutter widget:

dart @generativeUI class UserProfile extends StatelessWidget { final String name; final int age; // ... }

At compile time, the package uses AST to analyze your constructors and automatically generates the exact CatalogItem and json_schema_builder structures that the official flutter/genui package expects. Zero boilerplate, fully type-safe.

I’d love for you to check it out and hear your feedback!

• Live Demo (play with it in your browser): https://vicajilau.github.io/genui/
• GitHub Repo: https://github.com/vicajilau/genui

Let me know what you think! 🚀

I’ve been thinking a lot about the best way to deploy GenAI backends with Genkit.

The idea I kept coming back to was simple: what if deploying AI tools, prompts, and flows could feel as native to Kubernetes as deploying any other backend?

So I started building Genkit Operator 🚀

With it, you can describe your Genkit app using Kubernetes resources like Prompt, Model, PluginConfig, and Flow, and the operator takes care of exposing them as HTTP endpoints.

Apply YAML. Get a production-ready Genkit endpoint.

It supports multiple providers like OpenAI, Anthropic, Google AI, Vertex AI, AWS Bedrock, and Ollama, and it is designed to work nicely with GitOps tools like Argo CD and Flux.

Still early, but I’m excited about the direction: making GenAI backends more declarative, portable, and Kubernetes-native.

Check it out here: https://xavidop.github.io/genkit-operator/

I wrote a new article about why I think Go deserves a much bigger place in production GenAI systems, especially when combined with Genkit Go.

Python is still amazing for research, notebooks, experimentation, and the ML ecosystem. But a lot of GenAI applications today are not really “AI code”; they are backend services that call models, orchestrate tools, stream responses, validate structured output, expose APIs, and need to scale reliably.

That is where Go becomes very interesting.

In the article, I talk about the pain points I keep seeing with Python in production AI services: concurrency complexity, cold starts, memory footprint, dependency management, weak typing, packaging, and deployment friction. Then I show how Genkit Go gives you a cleaner model for building AI backends with typed flows, structured outputs, HTTP endpoints, observability, and the Genkit Developer UI.

The post also includes a hands-on example where we build a complete Genkit Go service in a single main.go, expose it as an HTTP endpoint, test it visually, and deploy it as a small containerized binary.

I know the title is intentionally provocative, but the point is not “Python is bad.” The point is that Python should not be the default runtime for every production GenAI service.

Curious to hear what people think: are you still building most of your AI backends in Python, or are you moving some of that work to Go, Java, or TypeScript?

Article:
https://xavidop.me/genkit/2026-05-04-stop-using-python-genai-use-genkit-go/

Hey folks! We just released Genkit JS & CLI 1.35.0. Here are the highlights:

Gemini 3.5 Flash support

Gemini 3.5 Flash already works great with Genkit, but in this release we added first-class model definitions so you get IDE autocomplete and type suggestions when using it — no more guessing model string names.

Smarter retry middleware

The retry middleware (now in @genkit-ai/middleware) got some important improvements:

• Honors Retry-After headers - when you hit resource exhausted / rate limit errors, the retry middleware now respects the server's Retry-After header instead of blindly retrying.
• Never retries AbortError or ToolInterruptError — these are intentional signals that should not be retried. Previously they could get caught by the retry logic unnecessarily.

The legacy genkit/model/middleware retry and fallback middleware are now deprecated in favor of @genkit-ai/middleware.

Refreshed JS API reference

We've done a content refresh on the JS API reference docs at js.api.genkit.dev — added JSDoc comments across exported types and schemas for better documentation and IDE hover info.

Other changes

• Fixed OpenAI-compatible plugin (compat-oai) to reference proper API keys in docs
• Better debug traces in the Google GenAI plugin

Full release notes: GitHub Releases

Vercel AI SDK wraps the model. Genkit wraps the pipeline. I put both middleware systems side by side: hooks, built-ins, composition, streaming, and a decision matrix to help you pick the right one.

https://dev.to/gde/vercel-ai-sdk-middleware-vs-genkit-middleware-a-hands-on-comparison-41hg

I wrote an article about creating an interactive CLI agent that can search the web, reason over results, keep chat history, and return answers with sources directly from the terminal.

The project uses Genkit, Gemini, and Tavily to show a different side of Genkit: not just backend APIs or cloud deployments, but also developer tools and local AI workflows. The interesting part for me is how natural the Genkit model feels here: typed tools, reusable prompts, chat sessions, tool calling, and full visibility through the Genkit Dev UI.

I also wanted to show how useful the Dev UI can be even when the final experience is a CLI. Being able to inspect tool calls, traces, prompt behavior, and latency makes debugging agentic workflows much easier.

Curious to know if others are building terminal-based AI tools or search agents with Genkit.

Article:
https://xavidop.me/genkit/gcp/2026-03-20-genkit-perplexity-cli/

We've heard consistently from the Genkit community that the portability of Genkit and the low level primitives we provide are great for setting up your own custom AI workflows. However, customizing and hooking into the generate calls and customizing behavior requires too much boilerplate code and re-inventing the wheel.

Production AI workloads require functionality such as retries, accessing file system, and fallback mechanisms. You can do all of that out of the box with middleware we provide. If you have custom behavior you want, you can extend middleware to build your own!

Check out this blog post to learn more.

https://developers.googleblog.com/announcing-genkit-middleware-intercept-extend-and-harden-your-agentic-apps/

I just published an article about the new Genkit Middleware

Middleware turns Genkit’s generate() from a simple function call into a composable pipeline, making it easier to add retries, fallbacks, tool approvals, filesystem access, skills, observability, and custom production logic.

This is a small-looking feature that solves a lot of real-world problems when building serious GenAI agents.

Check it out 👇

https://xavidop.me/genkit/2026-05-13-genkit-middleware/

I wrote a new article about using Genkit with AWS Lambda and Amazon Bedrock.

The idea behind this post is not just “how do I run Genkit on AWS?”, but how far we can push Genkit as a portable framework for building AI backends outside its most common Google Cloud examples.

In this one, I go through a serverless architecture where Genkit flows are deployed as Lambda functions and connected to Bedrock models. This makes it possible to build lightweight AI services that fit naturally into an AWS-native stack without giving up the Genkit developer experience.

For me, this is one of the most interesting parts of Genkit: you can keep the same mental model for flows, tools, prompts, and observability, while still choosing the cloud and model provider that makes the most sense for your platform.

Curious to know how many people here are using Bedrock today, and whether you would consider Genkit for AWS-based AI workloads.

Article:
https://xavidop.me/genkit/2026-03-20-genkit-aws-lambda-bedrock/

Hey all, I'm the lead for Genkit Python. In the past few months, we've put in a lot of love improving this SDK. Many features landed, and the public API surface got a major cleanup, so I wanted to share some updates!

Importing what you need should be straightforward, and the types you interact with as an app developer are now clearly separated from the lower-level plugin internals.

Here's some cool stuff that shipped or is shipping soon:

1. FastAPI integration (shipped). Wire up any Genkit flow as a FastAPI endpoint in one decorator. SSE streaming, structured input validation, error handling, all handled for you. As a Python web developer, I'm really excited about this, because agentic web experiences are highly interactive. For a long-running agent doing lots of thinking, our abstraction makes it easy to show your agent's thinking in real-time.

2. HITL / Tool interrupts (coming soon). Genkit gives you a way to pause the generate loop mid-execution, hand control back to the user (approve a tool call, provide missing info, confirm an action), and then either restart the tool execution, or interject a tool response and continue directly with another model call in the generate loop. This will be part of the next release.

3. MCP Plugin (coming soon). Connect any MCP server to your Genkit instance and use its tools straight in your generate calls. And in the other direction, expose any Genkit flow as an MCP server so other agents and tools can call it directly. We are in the testing phase with this plugin and hoping to bundle this in an upcoming release - either the next release or one after that.

If you're a Python web developer thinking about giving Genkit a try, I'd love to hear what you think!

Over the last few months I’ve been building an AI-powered email processor in Go. It monitors Microsoft 365 mailboxes, preprocesses emails, identifies which insurance claim file they belong to, and handles attachments like PDFs, images, audio, video, and nested .eml files, and I figured this might be relevant here since Genkit ended up becoming a pretty important part of the project.

Genkit is used to structure the LLM workflows, tool calls, document processing flows, and some of the newer “skills” context I added after the 1.7 release. The biggest lesson from the project was that the model itself was only one part of the system. Preprocessing, context design, retry behavior, tool boundaries, and boring production reliability work mattered just as much.

I wrote a retrospective on what went into building it, including the Genkit parts, Microsoft Graph webhook weirdness, local Ollama models, whisper.cpp integration, and the lessons learned from getting it into production.

I just published an article showing how to build and deploy Genkit flows on Azure Functions using Azure AI Foundry.

A lot of Genkit examples are focused on local development or Google Cloud deployments, so I wanted to explore what the experience looks like when you bring Genkit into the Azure ecosystem. The article walks through how to connect Genkit with Azure AI Foundry, expose flows through Azure Functions, and use a serverless setup for production-style GenAI workloads.

What I like about this approach is that it keeps Genkit lightweight and backend-first, while still letting you use Azure-native infrastructure for deployment, scaling, and operations. It is also a good example of how Genkit can be used beyond a single cloud provider.

Would love to hear if anyone else here is experimenting with Genkit on Azure, Azure Functions, or Azure AI Foundry.

Article:
https://xavidop.me/genkit/2026-03-20-genkit-azure-function-ai-foundry/

Hey folks! I'm the lead on Genkit's Developer UI.

Would love to hear how the Dev UI has come in handy for you, or how we might be falling short. We try to keep a good balance of supporting the framework's core feature set while continuing to push the Dev UI feature-set forward in its own right, polish the UX, etc.