Vibeleaderboard
Index / tool
Visit github.com
Category
AI Agents
Rank
No. 1362Tools index

Previous survey · No. 2929 ·

Pricing
Open Source
Type
TOOL
Use case
Agent Building
GitHub
66 stars
Latest release
v0.3.8
Date

About

Agent SDK for Go is an open-source SDK for building durable AI agents. It keeps agent state, tool calls and execution loops intact across process crashes, so an agent resumes where it stopped. It runs in-process with no setup through durable-go, or on Temporal or Restate for distributed execution, and each core component is a pluggable interface.

At a glance

Agent SDK for Go builds agents that can resume recorded work after an interruption. It is worth trying if tool calls take long enough that a crashed worker should not force the whole job to start again.

Good fit

Go teams implementing multi-step agent workflows with a need for recoverable execution.

Consider something else when

Use a simpler call loop if each task is short and safe to restart.

Start here

Build a scratch workflow with two steps and interrupt it after the first. Resume it and verify what is replayed and whether any external side effect happened twice.

Cost and requirements

Apache 2.0. The project documents an in-process runtime and optional Temporal or Restate backends. Model access and distributed infrastructure have separate requirements.

Limits to know

Durable execution does not make an external operation safe to repeat. Design tool calls for retries and test the failure points your workflow depends on.

Read the source review

What it does

A Go library for writing AI agents whose work survives a crash. Each model call, tool result and approval is written to a journal as it happens, and when the process comes back, finished steps are replayed from that record instead of being paid for again. By default the journal is a folder on local disk, so nothing extra has to run. Pointing the same agent at a Temporal or Restate server moves the loop onto that system and allows several worker processes. Around that core sit model clients for OpenAI, Anthropic, Gemini, DeepSeek and Ollama, MCP and A2A tool access, sub-agents, and a command-line chat client.

Why it's ranked here

The crash-recovery claim is backed by mechanism. The in-process mode journals every step to disk with no configuration, a runnable lab tells you to kill the process mid-stream and reconnect, and the docs spell out exactly what reconnecting loses on each backend. Apache 2.0 licensing, a security policy with a 48-hour acknowledgement window, vulnerability scanning that blocks a release, and an evaluation harness built on Promptfoo and DeepEval round it out. For Go teams running long or expensive agent jobs, this is a serious option that does not demand a workflow server on day one.

What's good

The documentation is candid about limits. It states that the local journal is plain JSON holding prompts and tool results, and shows how to supply your own engine for encryption. It warns that reconnecting only works while a run is still live, and that a finished run returns a specific error instead of replaying. Approvals default to the safe side: with no policy set, every tool call, MCP call and sub-agent handoff pauses for a person, and a rejected tool is reported back to the model so the run continues. Token or cost caps can pause a run for approval the same way.

Tradeoffs

Local durability is weaker than the server backends in two specific ways. Reconnecting replays each finished step as one block, with no seeking to a saved position, and an abandoned local run stays parked until some process reconnects to it, because no server picks it up. The single module declares Temporal, Restate, Weaviate, pgvector, Redis and a full set of OpenTelemetry exporters as direct requirements, so a project using only the in-process mode still carries that dependency list. It needs Go 1.26 or newer. Restate cannot be combined with Temporal, and its default callback address is loopback, which fails once Restate runs on another host unless you set it.

How to use it well

Fits Go services where an agent run is long, costly or waits on a person, and losing it to a restart would waste real tokens. Start on the default in-process mode and move to Temporal only when you need several workers sharing one queue. Save the run identifier before reading any events, start runs with a context that outlives the HTTP request, and set an approval policy explicitly, since the default pauses every tool call. Keep secrets out of prompts and tool output, because they land in the journal. It is a library, not a hosted service: you run and operate it yourself.

Technical notes+

Backend selection happens at construction: per docs/architecture.mdx, NewAgent picks local, Temporal or Restate from whichever config option is passed, and with Temporal it embeds a worker in the same process unless you split client and worker. README.md documents the local journal at ./agent_data/<agent_name> with a 7-day AutoPurgeAge default and an opt-out via local.DurabilityOff(); docs/advanced/durable-execution.mdx adds that the journal is plaintext JSON unless a caller-owned durable.Engine is set on LocalConfig.Engine, that local reconnect has no WithOffset(n>0) and emits one coalesced step_replayed event per completed step, and that GetAgentStream on a finished run returns ErrRunAlreadyCompleted. In internal/runtime/restate/server.go, startEndpoint TCP-probes the listen address for 2 seconds, then logs a warning and marks the endpoint started anyway; registerDeployment POSTs to the admin /deployments route with force:true, tries 3 times with linear backoff, gives up early on non-retryable 4xx, and falls back to http://127.0.0.1 plus the listen port when DeploymentURL is empty. docs/features/approvals.mdx makes RequireAllToolApprovalPolicy the default and sets approval timeout to agent timeout minus 30s. go.mod pins go 1.26.11 and lists go.temporal.io/sdk, restatedev/sdk-go, weaviate, pgvector-go, go-redis and the OTLP exporters in one require block. SECURITY.md names Dependabot and govulncheck, the latter hard-failing before GoReleaser.

Observed

License
Apache 2.0
Language
Go, requires Go 1.26 or newer
Install
go get for the library; agctl CLI as a prebuilt binary from GitHub Releases
Interfaces
Go library (Run, Stream, reconnect APIs) plus the agctl command-line client
Execution backends
In-process with a durable-go journal on local disk (default), Temporal, or Restate
Model providers
OpenAI, Anthropic, Gemini, DeepSeek, Ollama, plus a custom client interface
Tool protocols
MCP over stdio or streamable HTTP; A2A as server or client
Default approval policy
Require approval for every tool call, MCP call and sub-agent delegation
Local journal format
Plaintext JSON unless the caller supplies its own engine (docs/advanced/durable-execution.mdx)
Security reporting
GitHub Security Advisories, acknowledgement within 48 hours (SECURITY.md)
Evaluation
Eval harness using Promptfoo and DeepEval, plus a config-driven benchmark runner

Read from README.md, go.mod, docs/architecture.mdx, docs/advanced/durable-execution.mdx, internal/runtime/restate/server.go, cli/main.go, cli/cli.go, examples/simple_agent/main.go, examples/durable_agent/local/main.go, examples/agent_with_tools/approval/main.go, examples/agent_with_subagents/main.go, examples/agent_with_temporal_client/main.go, eval-harness/runner/main.go, docs/features/approvals.mdx, SECURITY.md.

Tags

goai-agentsdurable-executiontemporalrestatesdk

Tech Stack

Go

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.