[Submission] Temporal-first AI Agent SDK for Go

[vinodvanj]

Project link

https://github.com/agenticenv/agent-sdk-go

Language

Go

Short description

Temporal users building AI agents have to wire workflows, activities, and workers themselves — this SDK does that for you. Runs are durable Temporal workflows out of the box. LLM, tools, MCP, and conversation are all pluggable via interfaces.

Long Description

Building AI agents in Go? This SDK puts Temporal at the center — every agent run is a workflow, every LLM call and tool execution is an activity. You get durability, retries, and observability without writing any workflow code yourself.

What problem does it solve?

Building AI agents on Temporal is powerful but involves a lot of boilerplate — workflow definitions, activity registration, worker setup, signal handling for approvals, child workflows for sub-agent delegation. Most developers end up writing the same scaffolding from scratch every time. This SDK removes that work entirely — you define your agent, connect your LLM, and the Temporal plumbing is already done.

How it maps to Temporal

graph TD
    A[Agent] --> WF[Workflow: agent loop]
    W[Agent Worker] --> WF
    WF --> LLM[Activity: LLM call]
    WF --> Appr[Activity: approval]
    WF --> Child[Child Workflow: sub-agent loop]
    WF --> Tool[Activity: tool execution]
    WF --> Mem[Activity: save memory]
    Child --> LLM2[Activity: LLM call]
    Child --> Tool2[Activity: tool execution]
    Child --> Mem2[Activity: save memory]

Loading

Every LLM call, tool execution, MCP call, human approval step, and sub-agent delegation maps directly to a Temporal activity or child workflow — retries, timeouts, and failure handling all apply naturally without any extra code.

Problems it solves

Durability by default — agent runs survive crashes and deploys. No more lost runs when your server restarts mid-conversation.

Tools, MCP, and approvals without plumbing — connect any MCP server as a tool source, require human approval before sensitive tool calls, and delegate to specialist sub-agents — all wired into Temporal activities and child workflows automatically.

Multi-agent coordination — sub-agents run on their own task queues as child workflows. Stream events from the entire delegation tree through a single subscription.

Frontend ready — stream events conform to the AG-UI protocol out of the box, so agents work with any AG-UI compatible frontend like CopilotKit without any extra wiring.

Pluggable and extensible — built around interfaces for LLM providers, tools, MCP clients, and conversation storage. Bring your own implementation without touching the agent runtime. OpenAI, Anthropic, and Gemini included out of the box.

Observability out of the box — since every agent run is a Temporal workflow, you get full observability and tracing out of the box. Inspect run history, activity inputs and outputs, retries, and failures directly in the Temporal UI without any extra instrumentation.

Examples and reference app

• Examples — runnable examples for every feature including tools, MCP, sub-agents, approvals, streaming, and async runs
• agent-chat — reference web chat app showing the SDK wired into a real HTTP-backed application with durable conversations. Includes a separate Temporal worker deployment, AG-UI shaped streaming over SSE, and a Docker Compose setup running the API and worker from the same image — a real-world example of how agent runs stay durable across a split process deployment.

Author(s)

Vinod Babu Vanjarapu / https://avatars.githubusercontent.com/u/8429554?v=4

[github-actions]

Hi, I'm ZiggyBot! 🤖 Here's my pre-evaluation of this submission:

---

Criterion	Assessment
Useful to Temporal users	✅ Yes — Eliminates substantial boilerplate for Go developers building AI agents on Temporal by providing pre-wired workflows, activities, and workers for common agent patterns like tool execution, MCP integration, and sub-agent delegation.
Benefits clearly explained	✅ Yes — The README and submission clearly articulate the problem (repetitive scaffolding for agent workflows) and the solution (durability by default, pluggable interfaces, observability), with an excellent Mermaid diagram showing the Temporal mapping.
OSI Approved License	✅ Yes — Licensed under Apache License 2.0, which is OSI approved and commonly used in the Temporal ecosystem.
README with working instructions	✅ Yes — Includes a Getting Started section, runnable examples for every feature, a reference application (agent-chat), and Docker Compose setup for realistic deployment scenarios.

Overall: Looks good ✅

Notes:

• This is a thoughtfully designed SDK that genuinely puts Temporal at the center of AI agent execution rather than bolting it on as an afterthought. The architecture maps cleanly to Temporal primitives: agent loops as workflows, LLM calls and tool executions as activities, and sub-agent delegation as child workflows.
• The explicit handling of streaming and approval edge cases in the documentation shows production-minded thinking — acknowledging that live streams aren't backfilled after disconnection and that approvals degrade gracefully.
• The inclusion of AG-UI protocol support for frontend compatibility demonstrates attention to real-world integration needs.
• The reference app (agent-chat) with separate worker deployment is a valuable addition showing how to structure a production setup.
• Star count is modest (8) but the project appears well-maintained with CI, semantic versioning, and inclusion in Awesome Go.

Suggested questions for submitter:

• Are there any benchmarks or guidance on workflow history size for long-running agent conversations with many tool calls?
• How does the SDK handle continue-as-new for very long agent sessions to manage event history growth?

Teaching moment:

The project demonstrates an excellent pattern for heartbeating long-running LLM activities. The code sets a HeartbeatTimeout of 30 seconds with a heartbeat interval of 10 seconds, which allows Temporal to quickly detect stuck or crashed workers during lengthy streaming LLM calls without waiting for the full StartToClose timeout. This is particularly important for AI workloads where LLM calls can take minutes but you want fast failure detection if a worker dies mid-stream. The pattern of setting heartbeat timeout significantly shorter than the activity timeout (30s vs 30min) is a best practice for any long-running activity with side effects.
View in source ↗

---

---

ZiggyBot is an AI pre-screener based on Temporal's community mascot Ziggy. Final decisions are made by the community team.

Reviewer: Check the box below to generate a Contentful-ready long description for this submission.

• Generate long description if needed

[github-actions]

Hi, I'm ZiggyBot! 🤖 Here's my pre-evaluation of this submission:

---

Criterion	Assessment
Useful to Temporal users	✅ Yes — Provides a ready-made SDK that eliminates boilerplate for building AI agents on Temporal, with LLM calls, tool execution, approvals, and sub-agent delegation all mapped to workflows and activities.
Benefits clearly explained	✅ Yes — The README clearly explains how agent runs map to Temporal primitives (workflows, activities, child workflows), includes a Mermaid diagram, and documents durability, observability, and scaling benefits.
OSI Approved License	✅ Yes — Licensed under Apache License 2.0, which is OSI approved.
README with working instructions	✅ Yes — Includes a Getting Started section, runnable examples for each feature, a reference web app, and clear documentation of Temporal connection options and worker setup.

Overall: Looks good ✅

Notes:

• This is a well-structured, production-oriented SDK that solves a real pain point for Go developers building AI agents on Temporal. The mapping of AI agent concepts to Temporal primitives is thoughtful and well-documented.
• The inclusion of a reference app (agent-chat) showing a split client/worker deployment is excellent for demonstrating real-world usage patterns.
• Clear disclaimer that it's an independent community library, not affiliated with Temporal Technologies — good transparency!
• The AG-UI protocol compatibility is a nice touch for frontend integration.
• The project is still early (8 stars) but the code quality and documentation depth suggest a serious effort.

Suggested questions for submitter:

• None — the submission is thorough and the documentation is comprehensive.

Teaching moment:

This project demonstrates an excellent pattern for heartbeating long-running activities. In agent_workflow.go, LLM streaming calls and tool executions use a 30-second heartbeat timeout with a 10-second heartbeat interval. This ensures that if a worker crashes mid-stream, Temporal detects the failure quickly (within ~30 seconds) rather than waiting for the full StartToClose timeout (30 minutes). The comment explains the intent clearly: "fail stuck attempts soon after worker loss (<< StartToClose)." This is a best practice for any activity that may run for extended periods — heartbeats let you keep generous timeouts for legitimate long operations while still detecting actual failures promptly.
View in source ↗

---

---

ZiggyBot is an AI pre-screener based on Temporal's community mascot Ziggy. Final decisions are made by the community team.

Reviewer: Check the box below to generate a Contentful-ready long description for this submission.

• Generate long description if needed