Google’s Genkit Agents API Hits TypeScript and Go Preview

Google pushed its open-source Genkit framework into a new territory on July 1, putting a single chat() interface in front of the plumbing most full-stack teams have wired by hand. The Agents API arrives in preview for TypeScript and Go, packaging session history, tool execution, multi-agent delegation, and HTTP deployment behind one entry point.

The framing is deliberate. Conversational AI features need more than a model call, and the gap between a prototype and a production chat has been the part developers keep rebuilding.

What Genkit Agents Replaces

Conversational AI features usually need more than one model call. A support assistant that remembers a ticket, a copilot that runs over several turns, or a research agent that pauses mid-task all demand the same stack of capabilities: message history, a tool loop, streaming, persistence, and a frontend protocol. Building that stack by hand is the work most teams have repeated on every project, and most of it has little to do with what their app actually does.

Genkit, an open-source framework maintained by Google’s Firebase team, has been offering the lower-level pieces of that stack since May 2024. The new Agents API sits on top and pulls the boilerplate inside one interface. Define an agent on the server with a name and a system prompt, then drive it with the same chat() call whether it runs in process or behind HTTP. The May 2024 introduction to Genkit described the framework as a way to integrate AI features into apps, and the Agents API is the conversational layer on top of that base.

That promise is the spine of the launch. The constraints sit one layer down.

• Launch date: July 1, 2026
• Languages in preview: TypeScript, Go
• Other Genkit SDKs: Python (Beta), Dart (Preview)
• License: Apache 2.0
• Framework origin: May 2024 (Firebase Genkit beta)

The Two-Language Preview and Its Breaking-Change Warning

The preview covers exactly two languages: TypeScript and Go. The Python and Dart SDKs in the Genkit project are not part of the Agents API yet, and Google has not said when they will be. The team’s first release of Genkit in May 2024 shipped for JavaScript and TypeScript only, with Go arriving later, and the same staged approach is now repeating for the Agents layer. Google flagged the preview as unstable in plain language. The Genkit Agents launch announcement states the Agents API “can introduce breaking changes in minor version releases.”

For teams that need a stable contract between an agent and the rest of their application, that line is the load-bearing detail. It also signals where Google is placing the Agents API in its own taxonomy: still moving under users, with breaking changes possible in minor releases. The intended audience is full-stack developers already using Genkit to ship AI features in those two languages. The launch post frames agents as an application primitive built to live inside a user-facing app, not a managed runtime. Documentation and source code are available through the Genkit project, with feedback channeled through the same project’s issue tracker as the API moves toward general availability.

• TypeScript SDK: part of the Agents API preview
• Go SDK: part of the Agents API preview
• Python SDK: Beta, no Agents API preview support
• Dart SDK: Preview, no Agents API preview support

Server-Managed and Client-Managed State

Continuity between turns is the hardest part of any conversational feature. Genkit Agents gives the developer the choice about who owns that state, and that single switch reshapes the rest of the architecture.

Add a session store and the agent becomes server-managed. The server persists messages, custom state, and artifacts as snapshots; clients continue by sending back a session ID. Google ships several stores out of the box: Firestore for production multi-instance use, lighter stores for local work, plus a path to implement your own.

A client-managed agent works the other way. The developer leaves the store off, the server returns the full state, and the client sends it back on the next turn. That mode suits apps that already own persistence or that need stateless server deployments.

Every successful server-managed turn writes a snapshot. Developers can resume the latest state by sessionId or branch from an exact point by snapshotId, which lets a user revisit an earlier moment in a thread without disturbing the original. Branching shows up in the API as WithSnapshotID in the Go SDK and as a parameter on the chat surface in TypeScript. Alongside message history, an agent carries two more kinds of state. Custom state is typed application data such as workflow status, a task list, or a selected entity. Artifacts are generated outputs the user may inspect, download, or version on their own, such as a report or a patch. A tool updates either one through the active session, and Genkit streams the changes to the client as they happen. For developers building rich UIs, that streaming path is what makes a multi-step agent feel like an application instead of a request-response loop.

How an Agent Hands Off to a Specialist

One prompt rarely covers a real workflow. Genkit Agents lets a developer split work across specialized agents and add an orchestrator that delegates to them. The Agents middleware injects a delegation tool for each sub-agent, so the orchestrator model can route parts of a request to the right specialist. Delegation shows up as ordinary tool activity in the orchestrator’s stream, and specialist artifacts can merge into the parent session so the final answer can build on what each specialist produced.

Human approval is built into the same tool surface. A tool can pause an agent and hand control back to the user. The model decides outside input is needed, the tool interrupts, and the client approves, rejects, or supplies the missing value before the turn continues. The launch post describes a runtime that validates the resume payload against session history so a tool cannot be tricked into running with forged input. For payments, deployments, and any action a developer does not want to run automatically, that pause-and-resume path is the most concrete piece of new behavior in the preview.

The orchestrator pattern has limits. Genkit’s delegation middleware is deliberately lighter than what Google’s separate Agent Development Kit ships, and Google says so out loud in the launch post.

HTTP Deployment and Detached Execution for Long Jobs

Every Genkit agent is already a servable action. Putting one behind an HTTP endpoint takes a few lines: the route helpers return descriptors that mount on a standard http.ServeMux, wiring up the turn endpoint plus snapshot and abort companions. The same wire protocol is what the new JavaScript client speaks, so a JavaScript or Go backend serves any frontend identically.

For long-running work, the preview introduces detached execution. A client can detach a turn, close the tab, and reconnect later by snapshot ID. The agent keeps working on the server, writing progress to a pending snapshot that another session can poll, wait on, or abort. Google lists long research jobs, multi-step planning, and tool-heavy workflows as the target use cases. The point is to avoid holding a connection open or building a separate job queue just to wait on a model.

The frontend side is the new piece. A JavaScript client exposes the same chat() surface on the browser. sendStream() returns a chunk stream and a final response, and each chunk can carry text, custom state, or an artifact as it is produced. The client also resolves dynamic auth headers per request, applies streamed state patches, and continues the next turn with whatever session shape the agent uses. For apps already built on the Vercel AI SDK, an adapter called GenkitChatTransport wires useChat directly to a Genkit agent, so React code can talk to the agent without a custom transport layer.

Where Genkit Agents Stops and ADK Begins

The launch post spends one of its clearest sections drawing a line between Genkit Agents and Google’s Agent Development Kit (ADK). The split is on purpose, and it tells developers which framework fits which job.

Genkit agents are an application primitive, built to live inside a full-stack user-facing app. ADK is purpose-built for systems where multi-agent orchestration is the whole system, not just one feature. ADK pairs with Agent Runtime on the Gemini Enterprise Agent Platform for hosting, scaling, and managed sessions. The launch post names two specific handoff points: when multi-agent orchestration is the whole system, and when a developer wants a managed runtime rather than a library.

For context on where this sits inside Google’s wider AI push, see the related reporting on Google’s Gemini price cuts and the AI unit-cost shift.

The preview label, the breaking-change warning, and the ADK handoff together point in the same direction: Google is shipping a developer tool for the in-app layer and reserving the managed multi-agent platform for ADK. Developers can pull the preview from the open-source Genkit repository and read documentation on the Genkit documentation site. Feedback channels through the same repository’s issue tracker as the API moves toward general availability.

Frequently Asked Questions

What is Genkit Agents?

Genkit Agents is a new API layer inside Google’s open-source Genkit framework. It packages session management, tool execution, streaming, persistence, and a frontend protocol behind a single chat() interface, so a developer defines an agent once and drives it the same way in process or over HTTP. Genkit is built and used in production by Google’s Firebase team.

Which languages is the Genkit Agents API available for?

The Agents API is in preview for TypeScript and Go. Genkit also ships SDKs for Python (Beta) and Dart (Preview), but those SDKs are not part of the Agents API preview.

How is Genkit Agents different from Google’s Agent Development Kit (ADK)?

Google describes Genkit agents as an application primitive for full-stack apps and ADK as the framework for systems where multi-agent orchestration is the core product. ADK pairs with Agent Runtime on the Gemini Enterprise Agent Platform for managed hosting and scaling. The Agents middleware inside Genkit is deliberately lighter than ADK and is not designed to be the orchestration core of a large multi-agent system.

Is Genkit Agents production-ready?

No. Google labels the Agents API a preview and states it “can introduce breaking changes in minor version releases.” The framework is open source under the Apache 2.0 license, and Google has invited developer feedback through the Genkit repository before general availability.

How can developers try Genkit Agents?

Documentation is available on the Genkit website and the source code on the project’s open-source repository. Both can be reached from the Genkit developer site.