Agent SDK for Go
github.com/agenticenv/agent-sdk-go- 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.
Sources checked 2026-11-05. Source-based assessment.
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
Tech Stack
Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.