tRPC-Agent-Go is an Apache-2.0 Go framework for building production agent systems, aimed at Go service developers and platform teams who want LLM agents, graph workflows, tools, memory, and observability to live inside existing Go infrastructure instead of a separate Python stack.

What it is

tRPC-Agent-Go is a Go-native framework from the trpc-group that bundles LLM agents, graph workflows, tool calling, session and memory state, knowledge retrieval, agent self-evolution, evaluation, and OpenTelemetry observability into one stack. It is written in Go under the Apache-2.0 licence, published at https://trpc-group.github.io/trpc-agent-go/, and filed in this registry under Infrastructure & Operations / Monitoring & Observability. The project describes itself as Go-native by design: streaming runners, context cancellation, and service-friendly APIs.

The concrete problem it solves is the seam between an agent runtime and the Go services around it. Teams building agents in Python usually operate a second runtime, a second deployment model, and hand-rolled glue for tracing and persistence. tRPC-Agent-Go replaces that split by providing the agent loop, the workflow graph, the tool layer, and the telemetry inside the same language and process model as the surrounding service. Its GraphAgent is documented as functionally equivalent to LangGraph for Go, and its protocol layer covers AG-UI for frontends, A2A for agent-to-agent interoperability, and MCP for tools.

Key capabilities

• GraphAgent provides type-safe graph workflows with multi-conditional routing, positioned as the Go counterpart to LangGraph.
• Multi-agent orchestration ships as chain, parallel, and cycle-based workflows, for example chainagent.New("pipeline", chainagent.WithSubAgents(...)) and parallelagent.New("concurrent", parallelagent.WithSubAgents(tasks)).
• The tool ecosystem covers function tools through function.NewFunctionTool, MCP tools through mcptool.New(serverConn), web search, code execution, and custom services.
• Persistent state spans session, memory, artifacts, and knowledge retrieval, wired at runner level with memorysvc.NewInMemoryService() and runner.WithMemoryService(memory).
• Agent Skills are reusable SKILL.md workflow folders loaded from skill.NewFSRepository("./skills"), run through skilltool.NewLoadTool(repo) and skilltool.NewRunTool(repo, localexec.New()), with HTTP(S) .zip and .tar.gz sources, multiple roots, SKILLS_CACHE_DIR cache override, and repo.Refresh(). Hermes-style session reviews then extract, gate, and publish new skills.
• Prompt caching performs automatic cost optimization, with 90% savings reported on cached content.
• Observability and evaluation provide OpenTelemetry tracing and metrics, Langfuse integration via langfuse.Start(ctx) and agent.WithSpanAttributes using langfuse.user.id and langfuse.session.id, plus eval sets and metrics to track quality over time.

Who uses it and how

• Go service teams building customer support bots that need to hold context and resolve complex queries across sessions.
• Data analysis assistants that query databases, generate reports, and surface insights from inside an existing Go backend.
• DevOps automation teams, a natural fit given the project's monitoring and observability category, building deployment, monitoring, and incident response agents.
• Business process automation groups running multi-step workflows with human-in-the-loop steps.
• Research and knowledge management groups running RAG-powered document analysis and Q&A over their own corpora.

Getting started

Setup runs through Go APIs rather than a packaged installer: construct an agent with llmagent.New and execute it with runner.NewRunner("app", agent). Documentation and examples live at https://trpc-group.github.io/trpc-agent-go/.

How it compares

Among tools named in the facts, the closest reference point is LangGraph: tRPC-Agent-Go states that GraphAgent is functionally equivalent to LangGraph for Go, so it targets the same workflow-graph role for teams already committed to Go. It carries 1802 stars and 309 forks in this registry, with Apache-2.0 terms rather than a hosted commercial tier.

When to use it — and when not to

A self-hoster operates the Go services, a memory or persistence backend of their own choosing beyond the in-memory service, a skill cache directory, and an OpenTelemetry or Langfuse endpoint for the telemetry path. Teams not working in Go, or groups wanting a no-code agent builder, should look elsewhere, since the entire surface here is Go APIs and SKILL.md artifacts. The README is also thin on deployment specifics: it names no container image, no compose file, and no explicit module install command, so operators should expect to work from the API examples and documentation site.

// Chain agents for complex workflows
pipeline := chainagent.New("pipeline",
    chainagent.WithSubAgents([]agent.Agent{
        analyzer, processor, reporter,
    }))

// Or run them in parallel
parallel := parallelagent.New("concurrent",
    parallelagent.WithSubAgents(tasks))

// Persistent memory with search
memory := memorysvc.NewInMemoryService()
agent := llmagent.New("assistant",
    llmagent.WithTools(memory.Tools()),
    llmagent.WithModel(model))

// Memory service managed at runner level
runner := runner.NewRunner("app", agent,
    runner.WithMemoryService(memory))

// Agents remember context across sessions

// Any function becomes a tool
calculator := function.NewFunctionTool(
    calculate,
    function.WithName("calculator"),
    function.WithDescription("Math operations"))

// MCP protocol support
mcpTool := mcptool.New(serverConn)

// Start Langfuse integration
clean, _ := langfuse.Start(ctx)
defer clean(ctx)

runner := runner.NewRunner("app", agent)
// Run with Langfuse attributes
events, _ := runner.Run(ctx, "user-1", "session-1", 
    model.NewUserMessage("Hello"),
    agent.WithSpanAttributes(
        attribute.String("langfuse.user.id", "user-1"),
        attribute.String("langfuse.session.id", "session-1"),
    ))

// Skills are folders with a SKILL.md spec.
repo, _ := skill.NewFSRepository("./skills")

// Let the agent load and run skills on demand.
tools := []tool.Tool{
    skilltool.NewLoadTool(repo),
    skilltool.NewRunTool(repo, localexec.New()),
}

repo, _ := skill.NewFSRepository("./managed_skills")
evo := evolution.NewService(reviewerModel,
    evolution.WithManagedSkillsDir("./managed_skills"),
    evolution.WithSkillRepository(repo))
defer evo.Close()

runner := runner.NewRunner("app", agent,
    runner.WithEvolutionService(evo))

evaluator, _ := evaluation.New("app", runner, evaluation.WithNumRuns(3))
defer evaluator.Close()
result, _ := evaluator.Evaluate(ctx, "math-basic")
_ = result.OverallStatus