Runtimes Overview

Agent SDK for Go supports three execution backends. In-process is the default — pass no Temporal or Restate options — and is durable by default via durable-go, with no extra infrastructure. Temporal and Restate are opt-in distributed backends — import pkg/agent/runtime/temporal or pkg/agent/runtime/restate and add the matching config option when you need multi-process/horizontally-scaled execution. Your agent code (NewAgent, tools, prompts, streaming) stays the same. Only the configuration changes.

Comparison

	In-process	Temporal	Restate
Enable	Default — omit Temporal/Restate options	`temporal.WithTemporalConfig` or `temporal.WithTemporalClient`	`restate.WithRestateConfig`
Infrastructure	None beyond your LLM provider — durable-go journals to local disk	Running Temporal server or Temporal Cloud	Running Restate server or Restate Cloud
Where the loop runs	Inside your Go process	Durable workflow + activities	Durable Restate invocation + embedded SDK endpoint
Crash recovery	Yes by default — durable-go journal resumes from last completed step (`local.WithLocalConfig` to tune or opt out)	Yes — workflow history replays from last step	Yes — journal resumes from last completed step
Horizontal scale	Single process only	Add workers on task queues	Register multiple endpoint deployments
Split client / worker	Not applicable	`DisableLocalWorker` + `NewAgentWorker`	Not applicable — endpoint is embedded in `NewAgent`
Feature parity	Full	Full	Full
Reconnect fidelity	Step-granularity replay (one coalesced message per completed step), not the original tokens	Token-level — original AG-UI events replay	Token-level — original AG-UI events replay
Conversation backend	In-memory (single process)	Redis for split-process deployments	In-memory or Redis as needed for your topology

When to use in-process

Any single-process deployment that still wants crash recovery — this is the default, not a tradeoff
Zero-infrastructure deployments (serverless, scripts, single binary)
Skip it only if you need horizontal scaling or a client/worker split — that’s what Temporal/Restate add

See In-Process for details, the durability knobs, and the one remaining limitation (reconnect fidelity).

When to use Temporal

You need horizontal scaling by adding workers on a task queue
You want to split the agent client and worker across separate processes (NewAgentWorker)
Reconnect needs token-level fidelity (original AG-UI events replay, not coalesced steps)
You want mature, battle-tested workflow orchestration tooling (Temporal Web UI, etc.)

Crash recovery alone is not a reason to reach for Temporal — in-process already has it. See Temporal for cluster setup and SDK connection.

When to use Restate

You want durable orchestration with Restate’s ingress + embedded endpoint model
You need multiple registered endpoint deployments for scale
Reconnect needs token-level fidelity (original AG-UI events replay, not coalesced steps)

Crash recovery alone is not a reason to reach for Restate — in-process already has it. See Restate for server setup and SDK connection.

How runtime selection works

The SDK selects a backend from your NewAgent options. You never instantiate a runtime directly.

// In-process (default)
a, err := agent.NewAgent(
    agent.WithLLMClient(llmClient),
    agent.WithSystemPrompt("You are a helpful assistant."),
)

// Temporal
a, err := agent.NewAgent(
    temporal.WithTemporalConfig(&temporal.TemporalConfig{
        Host: "localhost", Port: 7233,
        Namespace: "default", TaskQueue: "my-app",
    }),
    agent.WithLLMClient(llmClient),
    agent.WithSystemPrompt("You are a helpful assistant."),
)

// Restate
a, err := agent.NewAgent(
    restate.WithRestateConfig(&restate.RestateConfig{
        Ingress:  restate.IngressConfig{URL: "http://localhost:8080"},
        Endpoint: restate.EndpointConfig{ListenAddress: ":9080", AdminURL: "http://localhost:9070"},
    }),
    agent.WithLLMClient(llmClient),
    agent.WithSystemPrompt("You are a helpful assistant."),
)

Provide either Temporal options or restate.WithRestateConfig, not both. For Temporal alone, provide either WithTemporalConfig or WithTemporalClient, not both.

Switching runtimes

In-process is already durable in development and production. Add Temporal or Restate only when you need distributed/horizontally-scaled execution — the agent code (tools, prompts, streaming, approvals) does not change.

Start in-process with no Temporal or Restate options — durable by default
Add temporal.WithTemporalConfig (or WithTemporalClient) or restate.WithRestateConfig when you need multi-process/horizontal scale
If you use conversation with a Temporal split-process deployment (agent + separate worker), switch from in-memory to Redis. See Conversation

In-Process

Default runtime — zero infrastructure

Temporal

Durable workflows, workers, and production deployment

Restate

Durable invocations with an embedded SDK endpoint

Overview

Getting Started

Runtimes

Features

Advanced

Observability

Testing & Evaluation

Production

Reference Apps

Comparison

When to use in-process

When to use Temporal

When to use Restate

How runtime selection works

Switching runtimes

In-Process

Temporal

Restate

​Comparison

​When to use in-process

​When to use Temporal

​When to use Restate

​How runtime selection works

​Switching runtimes

​Related pages

In-Process

Temporal

Restate

Comparison

When to use in-process

When to use Temporal

When to use Restate

How runtime selection works

Switching runtimes

Related pages