Building LLM Apps in Go Without Fighting the Language

If you've tried to build LLM applications in Go, you've probably felt the friction. Most of the tooling and examples assume Python, and the frameworks that do exist often feel like they were translated rather than designed for Go. Eino is a framework that takes the opposite approach—it's built for Go developers from the ground up, drawing inspiration from LangChain and Google ADK while following Go conventions.

What It Does

Eino is an LLM application development framework written in Go. It gives you three main pieces to work with. First, there are components—reusable building blocks like ChatModel, Tool, Retriever, and ChatTemplate, with official implementations for OpenAI, Ollama, and others. Second, there's an Agent Development Kit (ADK) for building AI agents with tool use, multi-agent coordination, context management, and interrupt/resume support for human-in-the-loop workflows. Third, there's a composition layer that lets you connect components into graphs and workflows, which can run standalone or be exposed as tools for agents.

The architecture is modular. You can start with a simple chat model, add tools as needed, and scale up to multi-agent systems when the task demands it. The framework is designed so that graphs and agents aren't separate worlds—you can compose graphs and then hand them to agents as tools, or build agents that coordinate other agents.

Why It's Cool

It's genuinely Go-first. The framework doesn't feel like a Python port with Go syntax slapped on top. The API design, the way you configure things, the iterator pattern for streaming responses—it all reads like idiomatic Go. If you're already comfortable with Go's error handling and interface patterns, you'll feel at home here.

The agent abstraction is practical. With ChatModelAgent, you configure a model, optionally add tools, and you have a working agent. The framework handles the ReAct loop internally—the agent decides when to call tools and when to respond. You don't have to wire up the reasoning loop yourself. That's a meaningful reduction in boilerplate for a common pattern.

DeepAgent handles the complex stuff. When a single agent isn't enough, DeepAgent lets you break problems into steps, delegate to sub-agents, and track progress. The example in the README—analyzing a CSV file, running Python code, and generating a chart—shows the kind of multi-step task this is meant for. You can configure it to coordinate specialized agents, run shell commands, execute Python, and search the web. That's a lot of capability without a lot of configuration.

Composition as a first-class concept. The graph and workflow layer isn't an afterthought. You can build reusable pipelines and then expose them as tools for agents. This means you're not locked into either "just agents" or "just workflows"—you can mix and match based on what the problem actually needs.

It comes with real examples. The README points to a separate examples repository with working code for common patterns and real-world use cases. That's more than many frameworks offer—you're not left guessing how to structure a project.

How to Try It

Getting started is straightforward. You'll need Go installed, then you can pull in the framework:

go get github.com/cloudwego/eino

From there, the quickest path is to configure a chat model and create an agent. Here's the minimal example from the README:

chatModel, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{
    Model:  "gpt-4o",
    APIKey: os.Getenv("OPENAI_API_KEY"),
})

agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Model: chatModel,
})

runner := adk.NewRunner(ctx, adk.RunnerConfig{Agent: agent})
iter := runner.Query(ctx, "Hello, who are you?")
for {
    event, ok := iter.Next()
    if !ok {
        break
    }
    fmt.Println(event.Message.Content)
}

To add tools, you pass them in through ToolsConfig:

agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Model: chatModel,
    ToolsConfig: adk.ToolsConfig{
        ToolsNodeConfig: compose.ToolsNodeConfig{
            Tools: []tool.BaseTool{weatherTool, calculatorTool},
        },
    },
})

The framework takes it from there—handling the tool-calling loop so you don't have to.

For more complex scenarios, check out the DeepAgent example and the ChatModelAgent examples. The full repository is at github.com/cloudwego/eino.

Final Thoughts

Eino is worth a look if you're building LLM applications in Go and want something that feels native to the language. It's not trying to be everything to everyone—it's a focused framework with clear separation between components, agents, and composition. The ADK is the standout piece here, especially the DeepAgent pattern for multi-step tasks. If you've been putting off building agents because the Go tooling wasn't there, this is a solid reason to reconsider. The examples repository gives you enough to get moving without reading through a novel of documentation first.