---
title: "Google ADK for Go agents (2026): adk-go release version, tools, session service database and human-in-the-loop tool confirmation — Cadenya"
url: "https://cadenya.com/other-content/google-adk-for-go-agents"
description: "Google ADK for Go (adk-go) in 2026: v2.5.0 and the google.golang.org/adk/v2 module, function tools and the OpenAPI toolset question, tool confirmation and long-running function tools for human-in-the-loop, the session service database on Postgres, context compaction, Anthropic Claude and OpenAI model support, the Temporal Google ADK integration, and Cadenya, which runs the agent loop, tool approvals and conversation state for your Go service."
---

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](/other-content/ai-agent-frameworks-in-go) 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](#what-does-cadenya-offer-that-adk-go-doesnt) 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](/other-content/openapi-specs-as-agent-tools-and-mcp) 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](/other-content/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](/other-content/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](/other-content/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](/other-content/durable-ai-agents-in-go) compares Temporal with the other Go engines, and [the Temporal cost breakdown](/other-content/temporal-cloud-vs-self-hosted-cost) 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](/docs/guides/the-basics/objectives) 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](https://cadenya.com/auth.md) explains. To create an account, sign up at [app.cadenya.com/signup](https://app.cadenya.com/signup?utm_source=cadenya.com&utm_medium=article&utm_campaign=google-adk-for-go-agents), then copy your API key from the API keys page at `app.cadenya.com/account/apiKeys`.