Google shipped the Genkit Agents API on July 1 — in preview for TypeScript and Go — and it makes a bet most agent frameworks are too timid to make: agents belong inside your app, not on top of it. Most frameworks want to become your backend. Genkit wants to be a feature you add to the backend you already have. One chat() interface, detached long-running turns, tools that stop and ask a human before proceeding, and state persistence that adapts to your architecture — whether you run on Firebase, Cloud Run, or anything that handles HTTP. If you’ve been stuffing polling loops, job queues, and WebSocket boilerplate into your AI integration, this is worth checking out.
One Interface for Every Agent Pattern
The design center of the Genkit Agents API is a single chat() object that handles every interaction pattern: one-shot replies, streamed multi-turn conversations, tool calls waiting on human approval, and long-running detached tasks. Same interface in development and production. Same interface whether the agent runs in-process or behind an HTTP endpoint.
Connecting a frontend to a remote Genkit agent looks like this:
import { remoteAgent } from 'genkit/beta/client';
const agent = remoteAgent<WeatherState>({
url: 'http://localhost:8080/api/weatherAgent',
});
const chat = agent.chat();
const res = await chat.send('Weather in Tokyo?');
console.log(res.text);The same chat object you use to drive a simple chatbot in tests drives it from the browser. If you’re building with Next.js, there’s a GenkitChatTransport adapter for the Vercel AI SDK that plugs directly into useChat — no custom transport layer needed.
Detached Turns: Let the Agent Work While the Client Moves On
Here’s the problem every developer building serious AI integrations runs into: the agent task takes thirty seconds. Maybe two minutes. Do you hold the HTTP connection open? Build a job queue? Stand up WebSockets? None of those feel right for what should be a routine “do this and tell me when you’re done” interaction.
Detached turns are Genkit’s answer. The client kicks off a task and disconnects. The agent keeps running server-side, writing progress to snapshots. The client polls — or reconnects later — by snapshot ID:
const task = await chat.detach('Write the quarterly market report.');
for await (const snapshot of task.poll({ intervalMs: 1000 })) {
renderStatus(snapshot.status);
}This is not an edge case. Any agent doing real work — multi-step planning, extended research, document analysis — needs async execution. Genkit bakes it into the API surface rather than leaving it as an exercise for the developer.
Interruptible Tools: Agents That Ask Before They Act
The moment an agent has permission to write to a database, call a payment API, or modify files, the stakes change. You need a way to pause execution, surface the proposed action to a human, and only proceed on approval.
Genkit calls these interruptible tools. Mark a tool as interruptible, and when the model selects it, the agent pauses and returns a pending action instead of executing immediately. The detail worth noting: the runtime validates the resume payload against session history. A client cannot forge an approval for an action the session never generated. That anti-forgery check is easy to overlook in the docs and harder than it sounds to implement correctly from scratch.
State Management: Two Models, Clear Trade-offs
State management is where Genkit forces a decision most frameworks paper over. You get two models:
- Server-managed state — the agent persists messages, custom state, and artifacts as snapshots. Clients reconnect by session ID. You can branch from a specific snapshot without disturbing the original thread. Built-in session stores: Firestore for production multi-instance deployments, in-memory for local development, file-based for local testing. Pluggable interface for custom stores.
- Client-managed state — the server returns full state every turn; the client sends it back on the next. Suits stateless deployments and data residency requirements. Trade-off: network payload grows as conversations lengthen.
Within state, Genkit separates two concerns: custom state (your typed application data — workflow status, selected entities, task lists) and artifacts (generated outputs a user can inspect or download). Keeping these distinct makes building multi-step agentic workflows considerably less messy.
Genkit vs. ADK: These Are Not the Same Product
ADK is built for multi-agent orchestration as a complete system — it assumes agents are your product and targets managed infrastructure on the Gemini Enterprise Agent Platform. The InfoQ technical breakdown of the two frameworks is clear on this distinction.
The Genkit Agents API is built for agents as a feature inside an app you’re already building. You host it wherever Node.js or Go runs. You own the deployment. The scope is deliberately narrower — and that’s the right call for most web and mobile developers. Use ADK when multi-agent orchestration becomes your entire system. Use Genkit when you’re adding agents to something you’re already shipping.
What’s Not Ready Yet
Python developers: the Agents API is not available to you yet. Python has Genkit support in beta, but the Agents API is TypeScript and Go only. Dart is in the same position. No timeline has been given for either language — a real limitation that the announcement doesn’t surface prominently enough.
The preview status means breaking changes can arrive in minor version releases. The ecosystem is also younger than LangChain’s 700-plus integrations. And Google’s product history creates reasonable skepticism about long-term commitment. None of these are reasons to ignore it — they’re reasons to go in with clear eyes.
Getting Started
The Genkit documentation has the full Agents API guide, including session store configuration and the Agent Runner in the developer UI — a testing interface that lets you drive interrupts and inspect snapshots without writing client code. The framework is open-source under Apache 2.0 on GitHub. The Google Developers Blog announcement covers the full-stack architecture in detail.
If you’re already using Genkit for AI features in a TypeScript or Go app, the Agents API is the upgrade that makes the framework production-capable for real agentic workflows. If you’re evaluating frameworks fresh, the full-stack story — server-side logic, typed client SDK, built-in streaming, no runtime vendor lock-in — is worth serious consideration.
