Google ADK for Go agents (2026)

Google ADK for Go (adk-go) is Google’s Agent Development Kit for Go, and its latest release is v2.5.0, under the module path google.golang.org/adk/v2. It gives a Go agent function tools, an MCP toolset, a session service with a database option, and human-in-the-loop tool confirmation, and all of it runs inside your own Go service.

So pick ADK Go when you want Gemini first, Google Cloud deploy targets, and Go code for every part of the agent. Pick the Temporal Google ADK integration when the agent loop has to survive crashes and you already run Temporal. Look at Eino or Genkit Go when you want a different set of model plugins (the Go frameworks page compares them). And if you’d rather not run the loop, the session database, or the approval plumbing at all, Cadenya is a hosted agent loop with tool approvals and conversation state built in, plus a Go SDK. A coding agent can set it up with no account, in a temporary workspace you claim later. What it offers is at the end.

Every price and limit below comes from each vendor’s own pages, checked on October 13, 2026.

ADK Go, Temporal, Eino and Genkit Go side by side

	ADK Go	ADK Go on Temporal	Eino	Genkit Go	Cadenya
Latest release	v2.5.0 (September 30, 2026), and v1.8.0 on the v1 line	The googleadk contrib module of the Temporal Go SDK	v0.9.21 (September 23, 2026)	v1.13.1 (September 3, 2026)	Go client at 1.9.0, on the same line as the TypeScript, Python, and Ruby SDKs
License	Apache 2.0	MIT for the Temporal Go SDK, Apache 2.0 for ADK	Apache 2.0	Apache 2.0	Apache 2.0 for the Go client, and no server to license
Go version	Go 1.25 or later for v2	go 1.26.6 in the contrib module’s go.mod	go 1.18 in go.mod	go 1.25.0 in go.mod	go 1.22 in go.mod
Approval primitive	RequireConfirmation on a function tool, or ctx.RequestConfirmation	The same ADK calls, with the decision sent as a Temporal signal	Interrupt, then resume from a checkpoint	DefineInterruptibleTool with a typed resume value	Approval on a tool set, decided with client.Objectives().ApproveToolCall
Where conversation state lives	A session service: in memory, a database through GORM, or Vertex AI	An ADK session inside the workflow, plus Temporal’s workflow history	A CheckPointStore you provide	A session store: in memory, file, Firestore, or your own	A durable event log per objective, on Cadenya
Model packages in Go	gemini, openaimodel (any OpenAI-compatible endpoint), apigee	Any model.LLM, built on the worker	”OpenAI, Ollama, and more”	Gemini, Claude, GPT, OpenRouter, and more	None: the model is a setting on a variation, from OpenRouter or your own OpenAI chat format endpoint
What you run	Your Go service and a session database	Your Go workers and a Temporal server	Your Go service and a checkpoint store	Your Go service and a session store	Your Go service only. The loop runs on Cadenya

adk-go release version: v1 and v2

ADK Go ships on two lines. The v2 line started with v2.0.0 on June 30, 2026, which added “our new graph-based workflow engine, built-in human-in-the-loop, dynamic orchestration and more.” It also moved the module, so install it with:

go get google.golang.org/adk/v2

The release note says it plainly: “v2 moves the module path to google.golang.org/adk/v2 and requires Go 1.25+.” The v1 line still ships under google.golang.org/adk (v1.8.0 came out on October 5, 2026), so check which path your imports use before you copy a sample.

The biggest code change in v2 is context unification. ToolContext and CallbackContext merged into one agent.Context, which is why tool handlers in v2 samples take ctx agent.Context. Test fakes that implemented the old interfaces need the new methods, and the migration guide suggests embedding agent.StrictContextMock so a fake keeps compiling as the interface grows.

Where does it deploy? The Cloud Run guide says “The adkgo deploy cloudrun command automates the deployment of your application. You do not need to provide your own Dockerfile.” Agent Runtime on Google Cloud takes Go agents from ADK Go v1.2.0, and “The deployment with Go does include the dedicated ADK API server.”

(If you point a coding agent at ADK, the README sends it to adk.dev/llms.txt, which includes the Go API reference.)

adk-go tools: function tools, MCP toolset and the OpenAPI toolset

A tool in ADK Go is usually a typed Go function wrapped with functiontool.New. ADK reads the argument struct to build the schema the model sees. The v2.5.0 tool directory also ships mcptoolset for MCP servers, agenttool for calling another agent as a tool, geminitool for Gemini’s built-in tools, and memory and artifact loaders.

What about an OpenAPI toolset? ADK’s OpenAPI tools page describes OpenAPIToolset, which creates one RestApiTool per operation in your spec. But that page’s support line reads “Supported in ADK Python v0.1.0”, and the v2.5.0 Go tool directory has no OpenAPI package. In Go, each REST endpoint is a function tool you write, or an MCP server you put in front of the API. OpenAPI specs as agent tools covers both routes.

adk-go tool confirmation and human-in-the-loop

Tool confirmation lets an ADK tool “pause its execution and interact with a user or other system for confirmation or to gather structured data before proceeding.” The docs list it for Go from v0.3.0, and the v2 quickstart calls it out as part of ADK Go 2.0.

The simplest form is a flag on the function tool, copied from ADK’s docs:

reimburseTool, _ := functiontool.New(functiontool.Config{
    Name:        "reimburse",
    Description: "Reimburse an amount",
    // Set RequireConfirmation to true to require user confirmation
    // for the tool call.
    RequireConfirmation: true,
}, func(ctx agent.Context, args ReimburseArgs) (ReimburseResult, error) {
    // actual implementation
    return ReimburseResult{Status: "ok"}, nil
})

Swap the flag for RequireConfirmationProvider to decide per call, for example return args.Amount > 1000. For a structured answer, the tool calls ctx.RequestConfirmation(hint, payload) on the first pass and reads ctx.ToolConfirmation() on the second.

The answer comes back as a message, not a callback. Your app sends a FunctionResponse named adk_request_confirmation to the ADK API server’s /run or /run_sse endpoint (or straight to the runner), and its id must match the function call ID from the confirmation request. So your app owns the screen, the stored call ID, and the reply.

Long-running function tools are the other pattern. Set IsLongRunning: true and ADK adds a line to the tool’s description: “Do not call this tool again if it has already returned some intermediate or pending status.” When the tool runs, “the agent runner pauses the agent run and lets the agent client to decide whether to continue or wait.” The docs add that these tools help you “start and manage long running tasks,” not perform them, and the Go sample tells you to “save the association between the FunctionCallID and the ticketID to handle the async response later.”

Human-in-the-loop approvals for AI agents compares this with other approval models.

adk-go session service: database, Postgres and context compaction

A session in ADK is one conversation: its events and its state. ADK Go ships three session services.

session.InMemoryService() is the default in samples, and the docs are blunt about it: “All conversation data is lost if the application restarts.” session.VertexAIService stores sessions on Google Cloud. And database.NewSessionService stores them in a relational database through GORM:

// Example using a local SQLite file. Any GORM dialector works, for
// example gorm.io/driver/postgres for PostgreSQL.
sessionService, err := database.NewSessionService(sqlite.Open("my_agent_data.db"), &gorm.Config{})
if err != nil {
    log.Fatal(err)
}
// Creates the tables and adds any columns a newer ADK release needs.
// Run it every time the application starts.
if err := database.AutoMigrate(sessionService); err != nil {
    log.Fatal(err)
}

The Go session service doesn’t create or update its own tables. You call database.AutoMigrate on every start, before the app serves traffic. If you manage the schema yourself, the docs say to add new columns before you deploy the ADK release that needs them: “Otherwise, writes to that table fail.”

Context compaction reached Go in v2.3.0. You set it on the runner, not on an App object, with compaction.Config fields such as CompactionInterval and OverlapSize, and you can pass your own summarizer model. ADK’s separate Resume feature, which restarts an interrupted invocation from its event log, is not listed for Go. Agent memory and context windows goes deeper on compaction.

adk-go model support: Anthropic Claude and OpenAI

The README says ADK is “optimized for Gemini” and “model-agnostic.” In Go, that means three model packages at v2.5.0: gemini, openaimodel, and apigee.

What about Anthropic Claude? ADK’s Claude page is not listed for Go, and its LiteLLM connector lists ADK Python only. So in Go, the route to a non-Gemini model is openaimodel, which ADK Go has had since v2.1.0. It targets the OpenAI Responses API by default. From v2.5.0 it can use the Chat Completions API instead, and to reach another provider, “set BaseURL to its endpoint and APIKey to its key.” Any gateway or provider that speaks Chat Completions works that way.

Genkit Go takes the plugin route: its provider list includes “Claude models through the Anthropic Messages API,” plus GPT, OpenRouter, and any OpenAI-compatible endpoint. Switching model providers for AI agents covers the tradeoffs.

Temporal Google ADK integration in Go

Temporal’s integrations list has a Go entry for Google ADK: “Run Google ADK agents as durable Temporal Workflows.” With it, “the agent’s orchestration loop runs inside a Temporal Workflow, each LLM call becomes a durable Temporal Activity, and any tool that does I/O runs as an Activity too.”

You keep the ADK code and change two things. The model becomes googleadk.NewModel("<model-name>"), which dispatches to an Activity while the real client lives on the worker. And you pass googleadk.NewContext(workflowCtx) to r.Run, so time and IDs replay deterministically. Tools run in the workflow by default, so a tool that touches the network goes through googleadk.ActivityAsTool or googleadk.NewMCPToolset.

Tool confirmation still uses ADK’s own call. “A sensitive tool calls ADK’s ctx.RequestConfirmation(hint, payload),” the workflow finds it with googleadk.PendingConfirmations, waits for a Temporal signal, and resumes the agent with googleadk.ConfirmationResponse. The sample handles “one pending confirmation per pass.”

You get durable steps, and you run a Temporal server and Go workers to get them. Durable AI agents in Go compares Temporal with the other Go engines, and the Temporal cost breakdown prices the server.

What does Cadenya offer that ADK Go doesn’t?

ADK Go gives you the parts of a Go agent, and you run them: the runner, the session database, the confirmation replies, and the deploy. Cadenya runs the agent loop, tool approvals, and conversation state for you, and your Go service talks to it through one client. Here’s what that covers:

1. Nothing else to run. No session database, no AutoMigrate on every start, no Temporal server, and no workers. The loop runs on Cadenya and your Go service stays a stateless web tier, so a deploy or restart never touches a running objective.
2. No server license to check. You host no server, so the only license to read is the client’s. The Go client, go.cadenya.com/cadenya-go, is Apache-2.0, and a CLI and a plain HTTP API cover anything else.
3. No old code to keep alive. An objective keeps its variation’s configuration snapshot even when you edit the variation, so an edit to the variation never changes an objective that’s already running.
4. SDKs with a steady release record. TypeScript, Python, Ruby, and Go SDKs are all at 1.9.0 under Apache-2.0, and the TypeScript SDK has shipped 113 versions since April 2026. The Go module declares go 1.22, where ADK Go v2 needs Go 1.25.
5. A price in one line. Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop. A loop is one LLM request, so an agent turn that calls the model 6 times is 6 loops, and there are no seats.
6. Tool approvals, decided with one Go call. Require approval on a tool set, for every tool or for tools that match a filter. The objective pauses on toolApprovalRequested, and your backend calls client.Objectives().ApproveToolCall(ctx, objectiveID, toolCallID, params). A denial carries a memo that steers the agent (“Use the read-only lookup tool instead.”), and several tools can wait at the same time.
7. Conversation state and resume, built in. Every objective carries a durable event log of its loop, which you can list or stream. When an objective enters STATE_WAITING, a Continue message from your user resumes the loop. Compaction is part of the variation’s config, and the API can trigger it on a running objective.
8. Tools generated from your OpenAPI spec. Point a tool set at an OpenAPI 3 document and every operation becomes a tool, with no function tool to write per endpoint. Cadenya re-checks a spec URL each hour, filters the list, and loads tools on demand with progressive discovery. MCP servers and plain HTTP endpoints work too.
9. Any model, on your own keys. The model is a setting on a variation, not a Go package, so switching providers needs no deploy. Use any model on OpenRouter or your own endpoint that speaks the OpenAI chat format, and weighted variations send more traffic to whichever model or prompt users rate higher.

How objectives work walks through an agent turn and the approve call, and the free plan needs no card.

No account yet? A coding agent can create a temporary workspace with cadenya workspaces create --temporary, run its first objectives there, and hand you a link to claim it, as auth.md explains. To create an account, sign up at app.cadenya.com/signup, then copy your API key from the API keys page at app.cadenya.com/account/apiKeys.