---
title: "Durable AI agents in Go (2026): Temporal Go SDK, Restate Go SDK, DBOS Transact Go, Hatchet Go SDK — Cadenya"
url: "https://cadenya.com/other-content/durable-ai-agents-in-go"
description: "Durable AI agents in Go in 2026: Temporal Go SDK release and AI agent integration, DBOS Transact Go durable workflows on Postgres, Restate Go SDK durable execution with awakeables, Hatchet Go SDK durable tasks with WaitForEvent, plus a hosted agent loop with a Go SDK."
---

Four durable execution engines ship a Go SDK for AI agents: the Temporal Go SDK, the Restate Go SDK, DBOS Transact Go, and the Hatchet Go SDK. Each one runs your Go code as durable workflows that pick up after a crash or a restart, and each has a human-in-the-loop primitive: a Temporal signal, a Restate awakeable, a DBOS `Recv`, and a Hatchet `WaitForEvent`.

So pick DBOS Transact Go when you already run Postgres and want a library, not a server. Pick Temporal when you want the Google ADK integration for Go and Worker Versioning. Pick Restate when one binary suits you and its Business Source License works for your use. Pick Hatchet when you want a task queue and durable tasks in one engine under MIT. And if you’d rather run no engine and write no agent loop, Cadenya is a hosted agent loop with a Go SDK, approvals, and resume built in. 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-temporal-restate-dbos-and-hatchet-dont) is at the end.

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

## Temporal Go, Restate Go, DBOS Go and Hatchet Go side by side

|  | Temporal Go SDK | Restate Go SDK | DBOS Transact Go | Hatchet Go SDK | Cadenya |
| --- | --- | --- | --- | --- | --- |
| Go module | go.temporal.io/sdk | github.com/restatedev/sdk-go | github.com/dbos-inc/dbos-transact-golang | github.com/hatchet-dev/hatchet | go.cadenya.com/cadenya-go |
| Latest Go release | v1.49.0, September 14, 2026 | v1.1.0, September 22, 2026 | v1.6.0, October 7, 2026 | v0.111.1, October 12, 2026 | 1.9.0 |
| Go SDK license | MIT | MIT | MIT | MIT | Apache 2.0 |
| What you run besides your Go code | Four services (Frontend, History, Matching, Worker) and Cassandra, PostgreSQL, or MySQL | One Restate server binary, under Business Source License 1.1 | Postgres, and no separate orchestration server | An API server, an engine, and PostgreSQL, with RabbitMQ optional | Nothing. The loop runs on Cadenya, and your Go service calls an HTTP API |
| Human-in-the-loop primitive in Go | workflow.GetSignalChannel(...).Receive | restate.Awakeable or restate.Signal | dbos.Recv and dbos.Send | ctx.WaitForEvent in a durable task | client.Objectives().ApproveToolCall or DenyToolCall |
| Code changes while runs wait | Worker Versioning or workflow.GetVersion patches | Immutable deployments | dbos.Patch() or versioning | Durable tasks replay a deterministic event log | An objective keeps its variation’s configuration snapshot, so no GetVersion or Patch() |
| Agent framework integration in Go | Google ADK (contrib/googleadk) | Go SDK primitives, TypeScript reference agent | Go SDK primitives | Go SDK primitives | Not needed: Cadenya is the agent loop |
| Managed option | Temporal Cloud, from $50 per million Actions | Restate Cloud | DBOS Pro, $99 a month | Hatchet Cloud, $0 to start | Hosted: free for 1,000 loops a month, then $49 a month for 50,000 |

The engine comparisons go deeper on cost and setup: [Restate vs Temporal](/other-content/restate-vs-temporal-for-ai-agents), [DBOS vs Temporal](/other-content/dbos-vs-temporal-for-ai-agents), [DBOS vs Restate](/other-content/dbos-vs-restate-for-ai-agents), and [the Temporal cost breakdown](/other-content/temporal-cloud-vs-self-hosted-cost). Inngest also ships a Go SDK, `inngestgo`, and [Inngest vs Temporal](/other-content/inngest-vs-temporal-for-ai-agents) covers it.

## Temporal Go SDK release and AI agent integration

The latest Temporal Go SDK release is v1.49.0, published September 14, 2026, and its headline is “Standalone Activities are now GA.” The module path is `go.temporal.io/sdk`, under MIT, and the server is MIT too.

For a Temporal Go SDK AI agent integration, Temporal’s Durable AI page lists one agent framework for Go: Google ADK, through the `go.temporal.io/sdk/contrib/googleadk` module. [Google ADK for Go agents](/other-content/google-adk-for-go-agents) covers how it runs.

Human-in-the-loop in the Temporal Go SDK is a signal. The workflow blocks on a channel, and your app sends the decision:

```
const ApproveSignal = "approve"

type ApproveInput struct {
	Name string
}

func GreetingWorkflow(ctx workflow.Context) error {
    logger := workflow.GetLogger(ctx)
	approverName := ""
	...
	// Block until the language is approved
	var approveInput ApproveInput
	workflow.GetSignalChannel(ctx, ApproveSignal).Receive(ctx, &approveInput)
	approverName = approveInput.Name
	logger.Info("Received approval", "Approver", approverName)
	...
}
```

The approval screen calls `temporalClient.SignalWorkflow` with the workflow ID and the signal name. Updates work too, when the caller needs a reply. **Either way, the model calls, the tool calls, and the stream to your UI are Go code you write as activities.**

## DBOS Transact Go: durable workflows on Postgres

DBOS Transact Go is a library, not a server. Its docs say it “provides a high-performance, easy-to-use library for durable workflows built on top of Postgres,” and “there’s no separate orchestration server and no infrastructure required besides Postgres.” You `go get github.com/dbos-inc/dbos-transact-golang`, point it at a Postgres URL, and each server process of your app connects to the same system database.

The latest DBOS Transact Go release is v1.6.0, published October 7, 2026, under MIT. It adds fencing tokens, workflow ID in use policies, and datasource migrations.

Human-in-the-loop in DBOS Go is a message. The workflow calls `Recv` on a topic, and your approval handler calls `Send` with the workflow ID:

```
func Send[P any](ctx Client, destinationID string, message P, topic string, opts ...SendOption) error

func Recv[R any](ctx Context, topic string, timeout time.Duration) (R, error)
```

Pass `WithIdempotencyKey` “to make a retried `Send` deliver at most once,” so a double click on **Approve** sends one message. For a streaming LLM reply, `dbos.WriteStream` pushes values to a client from inside the workflow, and “writes to a stream from a workflow happen exactly-once.”

DBOS lists a Google ADK integration too, but it installs with `pip install dbos dbos-google-adk`, so in Go the agent loop is yours. The managed side, Conductor, starts at $99 a month on DBOS Pro, and the library itself is “free forever.”

## Restate Go SDK durable execution for AI agents

The Restate Go SDK is `github.com/restatedev/sdk-go`, MIT, at v1.1.0 since September 22, 2026. Restate commits to “1.x semver guarantees for SDK and testing module.” Your Go handlers run in your own service, and the Restate server (one binary, under the Business Source License 1.1) drives them. The license’s one restriction is offering Restate itself as a “Public Restate Platform Service.”

Restate gives Go three durable primitives for outside input: signals, awakeables, and workflow promises. “All three survive retries and process restarts.” The Restate Go SDK awakeable is the one agents reach for in a human approval:

```
awakeable := restate.Awakeable[string](ctx)
awakeableId := awakeable.Id()

if _, err := restate.Run(ctx, func(ctx restate.RunContext) (string, error) {
  return requestHumanReview(awakeableId)
}); err != nil {
  return err
}

review, err := awakeable.Result()
if err != nil {
  return err
}
```

The reviewer’s click resolves the awakeable ID over HTTP. A signal is the reusable version, and Restate lists it for “agent steering, and human approvals.”

Restate’s AI section covers durable agents, sessions, and approvals with pause and resume. Its agent reference architecture is a TypeScript agent, so in Go you build the loop from the SDK primitives. [Restate vs Temporal](/other-content/restate-vs-temporal-for-ai-agents) covers the server side.

## Hatchet Go SDK durable tasks and WaitForEvent

Hatchet calls itself “a distributed task queue and workflow engine,” with SDKs and examples in Python, TypeScript, Go, and Ruby. The Go SDK lives in the main module, `github.com/hatchet-dev/hatchet`, MIT, tagged v0.111.1 on October 12, 2026.

A Hatchet durable task does two durable things: “they wait (for time to pass or events to be received), and they spawn child tasks.” Each one writes a checkpoint to a durable event log, and the code between checkpoints has to be deterministic.

Human-in-the-loop in the Hatchet Go SDK is an event wait, which Hatchet calls “the foundation for human-in-the-loop workflows”:

```
task := client.NewStandaloneDurableTask("durable-event-task", func(ctx hatchet.DurableContext, input DurableInput) (DurableOutput, error) {
	log.Printf("Waiting for user:update event, message: %s", input.Message)

	if _, err := ctx.WaitForEvent("user:update", ""); err != nil {
		return DurableOutput{}, err
	}

	log.Printf("Got event, processing message: %s", input.Message)

	return DurableOutput{
		ProcessedAt: time.Now().Format(time.RFC3339),
		Message:     "Processed: " + input.Message,
	}, nil
})
```

The second argument is a CEL expression, such as `input.user_id == '1234'`, so the task only wakes for the right approval. Self-hosted Hatchet is an API server, an engine, PostgreSQL, and optional RabbitMQ, and your workers connect to it. In Go, embedded mode also runs the engine in-process for local tests and CI.

## Deploying new Go code while workflows wait

An agent that waits for a person is a workflow that’s open when you deploy. Each engine has its own answer:

-   **Temporal Go SDK:** Worker Versioning lets “old Workers run old code paths and new Workers run new code paths,” so you “pin your Workflows to specific revisions.” Without it, `workflow.GetVersion(ctx, "Step1", workflow.DefaultVersion, 1)` branches old and new runs.
-   **Restate Go SDK:** every deployment is immutable, and “Restate then makes sure that requests start and end on the same version.”
-   **DBOS Transact Go:** `dbos.Patch()` “returns `true` for new calls” and `false` for runs that started before the change. Versioning is the other strategy.
-   **Hatchet Go SDK:** durable tasks “must be deterministic given the event history,” because a resumed task replays its log.

**In all four, a waiting approval runs against Go code you have to keep compatible.** [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) cover the patterns across languages.

## What does Cadenya offer that Temporal, Restate, DBOS and Hatchet don’t?

Temporal, Restate, DBOS, and Hatchet run your Go code durably, and your Go code still has to be the agent: the model calls, the tools, the stream, the compaction, and the approval screen. **Cadenya is the agent loop, with approvals and resume built in, and you drive it from Go with nothing to host.** Here’s what that covers:

1.  **Nothing else to run.** No Temporal cluster, no Restate server, no Postgres system database, no Hatchet engine, and no workers. The loop runs on Cadenya, and your Go service stays a stateless client of an HTTP API.
2.  **No server license to check.** There’s no BSL to read and no engine to patch, because you host no engine. The Go SDK is Apache-2.0.
3.  **No old Go code to keep compatible.** An objective keeps its variation’s configuration snapshot even when you edit the variation later. So there’s no `GetVersion`, no `Patch()`, and no pinned worker to keep alive for a waiting run.
4.  **A Go SDK on the same release line as the rest.** `go get go.cadenya.com/cadenya-go` works on Go 1.22 and later. The 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.
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 made during an objective, so there are no Actions, durable actions, or task runs to count.
6.  **The agent loop, already written.** Cadenya calls the model, runs the tools, streams each reply, and compacts the context window when a conversation gets long. On the four engines above, that’s the Go code you’d write, test, and version.
7.  **Human-in-the-loop approvals from Go.** Mark a tool as needing approval and the objective emits `toolApprovalRequested`. Your Go backend calls `client.Objectives().ApproveToolCall` or `DenyToolCall`, and a denial carries a memo the agent reads (“Use the read-only lookup tool instead.”). The React widget shows the same approvals to a person.
8.  **Resumable streaming in Go.** `client.Objectives().StreamEvents` returns a server-sent event stream, and `cadenya.WithLastEventID(stream.LastEventID())` picks up where a dropped connection left off. Webhooks use Standard Webhooks, and `client.Webhooks().Unwrap(rawBody, r.Header)` verifies each delivery.
9.  **Your models, on your keys.** The model is a setting on a variation, not Go code, so a model swap needs no deploy. You connect your own provider and pay it directly, since inference stays on your account. Weighted variations favor whichever model or prompt scores well.

[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=durable-ai-agents-in-go), then copy your API key from the API keys page at `app.cadenya.com/account/apiKeys`.