Building sophisticated AI applications, especially those that engage in multi-turn conversations, often involves a significant amount of repetitive “plumbing.” Think about a support assistant remembering past interactions or a copilot working across several turns – these require managing message history, tool execution, real-time streaming, data persistence, and frontend communication protocols. Traditionally, developers have had to wire up these complex components manually for every project, diverting focus from their app’s unique value.
Enter Genkit, an open-source framework designed to streamline the development of full-stack, AI-powered, and agentic applications. It supports a variety of popular languages including TypeScript, Go, Dart, and Python, making it versatile for any platform. Genkit’s new Agents API, currently in preview for TypeScript and Go, offers a powerful solution to this challenge, packaging all the necessary conversational infrastructure behind a single, intuitive interface.
Simplifying Conversational AI with Genkit Agents
The Agents API allows you to define an intelligent agent on your server, then interact with it using the same straightforward chat() API, whether it’s running locally or behind an HTTP endpoint. This unified approach eliminates the need for different abstractions as your application grows, handling everything from single-shot replies to complex multi-turn conversations with tool calls and streaming responses.
To get started, an agent simply needs a name and a system prompt to define its core purpose. As your features evolve, you can easily add more sophisticated elements like custom tools, persistent state management, and a dedicated session store. This modularity ensures your agent can grow from a simple bot to a highly capable assistant without a complete architectural overhaul.
Managing Conversation State: Client-Managed vs. Server-Managed
Every meaningful conversation requires continuity between turns, and Genkit provides flexible options for how this state is managed. You decide whether the client or the server is responsible for maintaining the conversation history and application-specific data. This crucial choice impacts your application’s architecture and user experience.
-
Server-Managed Agents: By integrating a session store, your agent becomes server-managed. The server handles persisting messages, custom application state, and any generated artifacts as snapshots. Clients simply send a session ID to continue the conversation, making this ideal for persistent chat applications, shared devices, or workflows where the client shouldn’t carry the full conversational burden.
Genkit supports various session stores, including Firestore for production-grade, managed persistence across multiple server instances. Lighter stores are available for local development, and the framework even allows you to implement custom storage solutions to fit your specific needs.
-
Client-Managed Agents: If you omit the session store, the agent operates in a client-managed mode. In this setup, the server returns the complete conversation state, and the client is responsible for sending it back with each subsequent turn. This approach is perfect if your application already handles its own persistence or if you require stateless server deployments for simplified scaling.
For server-managed agents, every successful turn generates a snapshot, allowing you to resume from the latest state using a sessionId or even branch from a specific point in history with a snapshotId. This powerful branching capability enables users to explore alternative paths in a conversation without disrupting the original thread, offering immense flexibility for complex workflows.
Beyond message history, Genkit agents manage two other key types of state: custom state and artifacts. Custom state holds your application’s internal data, like workflow status or selected entities, driving the next turn’s logic. Artifacts are generated outputs, such as reports or itineraries, which users might download or version. Tools can update either type of state, with changes streamed to the client in real-time.
Full-Stack Integration and Advanced Agent Capabilities
Genkit agents are designed for seamless integration into full-stack applications. Serving an agent behind an HTTP endpoint is straightforward, requiring just a few lines of code. Genkit’s route helpers provide the necessary descriptors to mount agents on a standard HTTP server, automatically wiring up turn endpoints, snapshot management, and abort companions.
The beauty of Genkit lies in its unified wire protocol, allowing a JavaScript or Go backend to serve any client identically. The remoteAgent() function returns a handle with the exact same chat() interface as a local agent, meaning the code you use for backend testing is precisely what drives your agent from a web browser. There’s no need to design separate request/response or streaming protocols.
Streaming is a core feature, built directly into the agent interface. The sendStream() method provides a chunk stream and a final response, with each chunk capable of carrying text, custom state updates, or newly generated artifacts as they become available. For developers already using the Vercel AI SDK UI library, the @genkit-ai/vercel-ai package offers an adapter, allowing you to connect your Genkit agent to Vercel’s AI Elements components while leveraging Genkit’s robust backend capabilities.
Human-in-the-Loop, Detached Turns, and Orchestration
Sometimes, an agent needs human input before proceeding. Genkit’s interruptible tools allow a model to decide when external input is necessary, pausing the agent and handing control back to the user. The client can then approve, reject, or provide missing information before the conversation continues, ensuring critical actions like payments or deployments are always user-confirmed.
For long-running tasks, Genkit supports detached turns when using server-managed state. A client can initiate a task, close the tab, and reconnect later using a snapshot ID. The agent continues its work on the server, saving progress to a pending snapshot that other sessions can poll, wait on, or even abort. This makes complex research, multi-step planning, and tool-heavy workflows practical without requiring an open connection or a separate job queue.
When a single agent can’t do everything, you can split work across specialized agents and use an orchestrator to combine their results. Genkit’s Agents middleware injects a delegation tool for each sub-agent, enabling the orchestrator model to intelligently route parts of a request to the right specialist. This provides full control over your orchestration strategy, allowing specialist artifacts to merge into the parent session for a comprehensive final answer.
When to Use Genkit Agents and Next Steps
Genkit agents are designed as an application primitive, intended to live within a full-stack, user-facing application. However, if your needs lean more towards building reliable multi-agent systems with graph-based workflows, built-in human-in-the-loop features, and dynamic orchestration, you might consider the Agent Development Kit (ADK) instead.
For server-managed agents, Genkit offers several session store options to match your deployment environment:
- Firestore: A managed, multi-instance database ideal for production.
- InMemory: Perfect for local development and testing.
- SQLite: A lightweight, file-based database for simple persistence.
- Custom: Implement your own solution to meet unique requirements.
The Genkit Developer UI further enhances the developer experience with a new Agent Runner. This tool allows you to initiate conversations, send turns, observe streamed output and state updates, manage tool interrupts, and inspect snapshots—all without writing any client-side code. It’s an invaluable resource for rapidly testing and debugging your agents.
The Genkit Agents API transforms the often-tedious process of building conversational, full-stack AI applications. By providing a unified interface for agent definition, state management, and client-server communication, it lets you focus on your application’s unique features rather than reinventing the underlying plumbing. Dive into the full-stack agents documentation to get started, or explore Genkit if you’re new to the framework. As the API is in Beta, your feedback on what you build and what improvements you’d suggest is highly valued!
Source: Google Developers Blog
