---
title: "AI agent frameworks in Go (2026): Genkit Go 1.0, CloudWeGo Eino interrupt and checkpoint, LangChainGo maintenance status, trpc-agent-go — Cadenya"
url: "https://cadenya.com/other-content/ai-agent-frameworks-in-go"
description: "Go agent framework comparison for 2026: Genkit Go 1.0 release, interrupts and session stores; CloudWeGo Eino ADK interrupt, resume and CheckPointStore; LangChainGo maintenance status and v0.1.15; trpc-agent-go graph interrupt, resume and checkpoint; multiple LLM providers in Go; plus a hosted agent loop with a Go SDK."
---

The Go agent frameworks coding agents compare in 2026 are LangChainGo, CloudWeGo Eino, Genkit Go, and trpc-agent-go. All four call Anthropic, OpenAI, and Gemini models through one Go interface, and three of them (Eino, Genkit Go, and trpc-agent-go) can interrupt for human-in-the-loop approval and resume from a checkpoint or session store you run.

So pick Genkit Go when you want Google’s Go framework, now on its 1.x line. Pick Eino for an ADK with ReAct agents, DeepAgent, and graphs from CloudWeGo. Pick trpc-agent-go for LangGraph-style graphs with checkpoints in SQLite or Redis. Pick LangChainGo when you need a model call and a long list of provider packages. And if you’d rather not run the loop or its checkpoint store at all, Cadenya is a hosted agent loop with a Go SDK, approvals, and resume built in, and 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-eino-genkit-langchaingo-and-trpc-agent-go-dont) is at the end. (Google’s ADK for Go has [its own page](/other-content/google-adk-for-go-agents).)

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

## Go agent framework comparison: LangChainGo, Eino, Genkit Go, trpc-agent-go

|  | LangChainGo | Eino | Genkit Go | trpc-agent-go | Cadenya |
| --- | --- | --- | --- | --- | --- |
| Who’s behind it | A community project at github.com/tmc | CloudWeGo, with security reports going to Bytedance | Google: “built and used in production by Google” | The tRPC group, with thanks to Tencent business units | Cadenya, which hosts the loop |
| License | MIT | Apache-2.0 | Apache-2.0 | Apache-2.0 | Apache-2.0 SDK (go.cadenya.com/cadenya-go) |
| Latest release | v0.1.15, October 5, 2026 | v0.9.21, September 23, 2026 | go/v1.13.1, September 3, 2026 | v1.11.2, August 20, 2026 | Go SDK 1.9.0 |
| The agent loop | A ReAct agent and an Executor | ChatModelAgent (ReAct), DeepAgent, and graphs | Generate with tools, plus agents with session stores | LLMAgent, GraphAgent, and chain and parallel agents | Hosted: Cadenya calls the model, runs the tools, and compacts the context |
| Human-in-the-loop pause | No interrupt or checkpoint API in the repo | Interrupt and resume from a CheckPointStore | Interrupt tools and a ToolApproval middleware | graph.Interrupt, then resume from a checkpoint | A tool marked for approval pauses on toolApprovalRequested |
| Where paused state lives | Wherever your code puts it | Your CheckPointStore: in-memory built in, Redis recommended | Your session store: in-memory, file, Firestore, or custom (Postgres) | Your CheckpointSaver: in-memory, SQLite, or Redis | On Cadenya, with nothing to run |
| MCP tools | No MCP package in tools | An mcp tool component | An mcp plugin | An mcp tool package | Tool sets from an MCP server or an OpenAPI 3 document |

The pattern is the same in all four. **The framework runs inside your Go process, and the paused state lives in a store you pick, run, and back up.**

## LangChainGo maintenance status and latest release

LangChainGo shipped v0.1.15 on October 5, 2026, almost a year after v0.1.14 (October 20, 2025). The release notes call it “a patch release that replaces three retired default models, adds typed reasoning content and OpenAI web search, and fixes a number of provider bugs.” The Anthropic default is now `claude-sonnet-4-6`.

Who maintains it? The README answers that one itself: “There is a momentum for moving the development of langchaingo to a more community effort,” and it asks anyone who wants to be a maintainer to say so on its Discord. The repository is MIT licensed, not archived, and had commits as recently as October 11, 2026.

LangChainGo’s agents package is a ReAct agent plus an Executor that “is an Agent and set of Tools.” The repository has no interrupt or checkpoint API, so a human approval step is code you write around it. It fits best as a provider library, which the next sections come back to.

## Genkit Go 1.0 release: interrupts and session stores

Genkit Go reached 1.0 on September 9, 2025, and the current Go release is go/v1.13.1.

An interrupt in Genkit is “a special kind of tool that can pause the LLM generation-and-tool-calling loop to return control back to you.” Here’s the tool from Genkit’s docs:

```
askQuestion := genkit.DefineTool(g, "askQuestion",
    "use this to ask the user a clarifying question",
    func(tc *ai.ToolContext, input QuestionInput) (string, error) {
        return "", ai.InterruptWith(tc, InterruptMetadata{
            Reason:  "need_clarification",
            Choices: input.Choices,
        })
    },
)
```

“Genkit immediately returns a response on receipt of an interrupt tool call.” You answer with `RespondWith()` and send the history back through `ai.WithToolResponses()`. For an answer that arrives later from another process, the docs say to “Store resp.History() and resp.Interrupts() under an approval ID” and rebuild the call when the decision comes back.

Agents do that storage for you: “the session store holds the paused history, so the resuming request carries only the decision.” The built-in stores are in-memory, a JSON file per snapshot, and Firestore. For Postgres, Redis, or Cloud SQL, the docs say to “implement a custom aix.SessionStore.” There’s also a `ToolApproval` middleware that “interrupts tool execution unless the tool is in \[AllowedTools\], the call has been explicitly approved on resume, or the \[Judge\] model allows it.”

## CloudWeGo Eino ADK: interrupt, resume and CheckPointStore

Eino describes itself as “an LLM application development framework in Golang” that “draws from LangChain, Google ADK, and other open-source frameworks.” Its ADK covers “interrupt/resume for human-in-the-loop”, and the README says “Any agent or tool can pause execution for human input and resume from checkpoint.”

The runner takes a checkpoint store, and every run gets a checkpoint ID. From Eino’s human-in-the-loop docs:

```
runner := adk.NewRunner(ctx, adk.RunnerConfig{
    EnableStreaming: true,
    Agent:           a,
    CheckPointStore: store.NewInMemoryStore(),
})
iter := runner.Query(ctx, "book a ticket for Martin, to Beijing, on 2025-12-01, the phone number is 1234567. directly call tool.", adk.WithCheckPointID("1"))
```

When the person decides, you resume with the same checkpoint ID and the interrupt’s ID:

```
iter, err := runner.ResumeWithParams(ctx, "1", &adk.ResumeParams{
    Targets: map[string]any{
       interruptID: apResult,
    },
})
```

The store interface is two methods, `Get` and `Set`, over raw bytes keyed by checkpoint ID. The in-memory store ships with Eino, and the docs say “In actual use, distributed storage like redis is recommended.” That matters once you run more than one replica: resuming on another server works “As long as the CheckPointID is the same for both, and the CheckPointStore configured for Runner is distributed storage.”

## trpc-agent-go graph interrupt, resume and checkpoint

trpc-agent-go’s GraphAgent is “functionally equivalent to LangGraph for Go”, and its graph package “supports human-in-the-loop (HITL) workflows through interrupt and resume functionality.” A node pauses with `graph.Interrupt`, from the graph docs:

```
sg.AddNode(nodeHumanReview, func(ctx context.Context, s graph.State) (any, error) {
    app := s[stateKeyApplication].(string)
    decision, err := graph.Interrupt(ctx, s, "approval",
        fmt.Sprintf("Please approve: %s", app))
    if err != nil {
        return nil, err
    }
    return graph.State{stateKeyDecision: decision}, nil
})
```

To resume, you “run again with the same `lineage_id` and the `checkpoint_id` from the interrupt event”, passing the answer for that key. “Checkpointing must be enabled (configure a `CheckpointSaver`) for resume to work.” The repo ships three savers in `graph/checkpoint`: in-memory, SQLite, and Redis. Sessions are a separate service with more backends, Postgres, MySQL, MongoDB, and Redis among them.

Tools come in as Go functions, MCP servers, or an `openapi` tool package, and models through `openai`, `anthropic`, `gemini`, `bedrock`, `ollama`, and `hunyuan` packages.

## Go LLM library with multiple providers: Anthropic, OpenAI, Gemini

Every framework here swaps providers behind one interface. They differ in which packages they ship and where model fallback lives.

-   **Genkit Go**: “Configure a model plugin once, then call any model through the same API.” Plugins cover Google AI, Vertex AI, Anthropic, Ollama, and an OpenAI-compatible plugin with subpackages for OpenAI, OpenRouter, DeepSeek, xAI, and more. A `Fallback` middleware “tries alternative models when the primary model fails with a retryable error status.”
-   **Eino**: the `eino-ext` repo has model components for OpenAI, Claude, Gemini, DeepSeek, Qwen, Ollama, OpenRouter, and Ark. The Claude component reaches Claude through Anthropic, Bedrock, or Vertex AI, and it takes a thinking config.
-   **LangChainGo**: `llms` has packages for Anthropic, OpenAI, Google AI, Bedrock, Mistral, Cohere, Ollama, watsonx, and more. The v0.1.15 notes also say “Multi-turn tool calling with Gemini 3 is not yet supported,” with a fix planned for the next release.
-   **trpc-agent-go**: OpenAI, Anthropic, Gemini, Bedrock, Ollama, Hugging Face, and Hunyuan packages, plus a `failover` package.

In each case the model name and the API key live in your Go code or its config, so a provider switch is a deploy. [Switching model providers](/other-content/switching-model-providers-for-ai-agents) covers that problem on its own.

## Go agent framework, durable and human-in-the-loop: what you run

None of the four is a server. Each one is a library your Go service imports, so “durable” means durable as the store you plug in. With Eino that’s your `CheckPointStore`, with Genkit your session store, and with trpc-agent-go your `CheckpointSaver`. LangChainGo leaves it to you entirely.

So a production setup is your service, a Redis or a database for paused runs, the code that turns an interrupt into a screen someone clicks, and the resume handler that validates the answer before it goes back in. Genkit’s docs spell out that last part: `Generate` “does not check that a restarted input matches what the model originally asked for.” If you’d rather put a durable engine under the framework, [durable execution for AI agents](/other-content/durable-execution-for-ai-agents) and [human-in-the-loop approvals](/other-content/human-in-the-loop-approvals-for-ai-agents) compare the options.

## What does Cadenya offer that Eino, Genkit, LangChainGo, and trpc-agent-go don’t?

Eino, Genkit Go, LangChainGo, and trpc-agent-go give your Go service an agent loop to run and a checkpoint store to wire up. **Cadenya runs the loop, the approvals, and the paused state for you, and your Go code talks to it through an SDK.** Here’s what that covers:

1.  **Nothing else to run.** No checkpoint store, no session store, no Redis, no Firestore, and no resume handler. The loop runs on Cadenya and your Go service stays a stateless web tier, so your deploys and restarts never touch a running objective.
2.  **No server to license or patch.** Your Go code imports `go.cadenya.com/cadenya-go`, which is Apache-2.0, or calls the plain HTTP API. Every objective carries a durable event log you can list after a run or stream while it works.
3.  **No old code to keep alive while approvals wait.** An objective keeps its variation’s configuration snapshot even when you edit the variation. With a framework, a paused checkpoint resumes on whatever code you deployed since.
4.  **A Go SDK at 1.9.0.** SDKs for TypeScript, Python, Ruby, and Go are all at 1.9.0 under Apache-2.0, and the TypeScript SDK has shipped 113 versions since April 2026. The Go module targets Go 1.22.
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.
6.  **Human-in-the-loop approvals, screen included.** Mark a tool as needing approval and the objective pauses on `toolApprovalRequested`, and your backend approves or denies it by `toolCallId`. The decision can come from your Go backend through the API, a webhook handler, or a person in the React chat widget. Several tool calls can wait at once, and a denial can carry a memo that steers the agent.
7.  **The agent loop, already written.** Cadenya calls the model, runs the tools, streams each event over SSE, and compacts the context window when a conversation gets long. Point a tool set at an OpenAPI 3 document or an MCP server, and Cadenya re-checks a spec URL each hour.
8.  **Any model, on your own keys.** The model is a setting on a variation, not a line of Go, so switching providers needs no deploy. Use any model on OpenRouter or your own endpoint that speaks the OpenAI chat format, and weighted variations route more traffic to whichever model users rate higher.
9.  **Resumable streaming.** The widget’s conversation event stream honors `Last-Event-ID`, so a dropped connection picks up where it left off.

[How objectives work](/docs/guides/the-basics/objectives) walks through an agent turn, 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=ai-agent-frameworks-in-go), then copy your API key from the API keys page at `app.cadenya.com/account/apiKeys`.