In-Process Runtime

The in-process runtime is the default. When you call NewAgent without Temporal or Restate options, the agent loop runs directly inside your Go process — no external orchestration server.

Enable

Omit all Temporal and Restate configuration:

a, err := agent.NewAgent(
    agent.WithLLMClient(llmClient),
    agent.WithSystemPrompt("You are a helpful assistant."),
)
if err != nil {
    return err
}
defer a.Close()

agentRun, err := a.Run(ctx, "Hello", nil)
if err != nil {
    // handle start error
}
result, err := agentRun.Get(ctx)

See Quickstart for a complete example.

How it works

When you call Run or Stream, the SDK executes the full agent loop in your process:

Load conversation history and recalled memory (when configured)
Call the LLM with the merged tool list
Execute tool calls and append results
Repeat until the model finishes or the iteration limit is reached
Return the result or stream events back to your caller

Everything happens in-process — no network hops, no external orchestration.

Capabilities

All SDK capabilities are available on the in-process runtime:

LLM providers (OpenAI, Anthropic, Gemini, custom)
Tools, MCP, A2A, sub-agents
Conversation (in-memory), memory, retrieval (RAG)
Streaming, AG-UI events, hooks
Human-in-the-loop approvals
OpenTelemetry observability

Durable execution (crash recovery) and durable reconnect (GetAgentRun / GetAgentStream + WithOffset) require the Temporal or Restate runtime. Temporal also offers horizontal worker scaling via NewAgentWorker; Restate scales via multiple registered endpoint deployments.

Limitations

Limitation	Detail
No crash recovery	If the process exits mid-run, the run is lost — no replay, no resume
No crash reconnect	`GetAgentRun` / `GetAgentStream` return `ErrRunNotFound` / `ErrStreamNotFound` after a crash; `Events(..., WithOffset(n))` with `n > 0` returns `ErrStreamOffsetNotSupported`
Single process	No horizontal worker scaling
In-memory conversation only	Redis works technically, but Temporal split-process deployments require Redis for shared conversation
Split client/worker	Available on Temporal via `DisableLocalWorker` and `NewAgentWorker`

Handles from Run / Stream are same-process only. For crash reconnect (GetAgentRun, GetAgentStream + WithOffset), use the Temporal or Restate runtime.

Error handling

On in-process, errors are returned directly to the caller:

Run

run, err := a.Run(ctx, prompt, nil)
if err != nil {
    // Start error (context cancelled, config issue)
    // If nil, the run started; check result via Get
}

result, err := run.Get(ctx)
if err != nil {
    // Run error (LLM failure, tool panic, timeout, context cancelled)
    // result may be nil or partially populated
}

Stream

stream, err := a.Stream(ctx, prompt, nil)
if err != nil {
    // Start error
}

events, err := stream.Events(ctx)
if err != nil {
    // Events subscribe error — including ErrStreamOffsetNotSupported
    // when WithOffset(n) is used with n > 0
}

for ev := range events {
    // Channel closes after RUN_FINISHED or RUN_ERROR.
    // Cancelling Stream's ctx cancels the run (terminal event still delivered).
}

Any panic inside a tool call is caught and returned as a RUN_ERROR event / error result, with the panic message included. The run does not propagate the panic to your caller.

When to use

Scenario	In-process fit
Local development and unit testing	Ideal
CI pipelines and integration tests	Ideal
Simple API or script with short runs	Good
Production chat with crash recovery required	Use Temporal or Restate
Multi-process or horizontally scaled execution	Use Temporal (`NewAgentWorker`) or Restate (multiple endpoint deployments)

Switch to a durable runtime

Import a durable runtime package and add its config option — no other code changes: 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."),
)

A running Temporal or Restate server is required. See Temporal or Restate.

Examples

Simple Agent

Minimal in-process agent with Run()

Stream

Streaming tokens and tool events in-process

Overview

Getting Started

Runtimes

Features

Advanced

Observability

Testing & Evaluation

Production

Reference Apps

Enable

How it works

Capabilities

Limitations

Error handling

Run

Stream

When to use

Switch to a durable runtime

Examples

Simple Agent

Stream

​Enable

​How it works

​Capabilities

​Limitations

​Error handling

​Run

​Stream

​When to use

​Switch to a durable runtime

​Examples

Simple Agent

Stream

Enable

How it works

Capabilities

Limitations

Error handling

Run

Stream

When to use

Switch to a durable runtime

Examples