Eino: Go Framework for LLM Apps and AI Agents

What Eino is

Eino (pronounced roughly "aino") is an Apache-2.0 framework for building LLM applications and AI agents in Go. It is part of the CloudWeGo project family, and its security policy routes vulnerability reports to ByteDance Security. The README says it draws on LangChain, Google ADK and other open-source frameworks, but is designed to follow Go conventions rather than port Python idioms.

The target audience is Go teams that want to ship model-backed features, retrieval pipelines or tool-using agents inside existing Go services, without adding a Python sidecar. The framework covers the full stack: component abstractions for models, tools and retrievers; an Agent Development Kit for autonomous agents; and graph-based composition for deterministic pipelines.

How it works

Eino is split across several repositories. The main eino repo holds type definitions, the streaming mechanism, component abstractions, orchestration, agent implementations and callback aspects. eino-ext holds concrete component implementations, callback handlers, evaluators, prompt optimizers and Eino Devops tooling for visual development and debugging. eino-examples holds working applications.

There are two ways to build:

• Agents (ADK): ChatModelAgent uses a ChatModel as the decision-maker and Tools as the action space, and runs a ReAct loop: reason, call tools, observe, respond. A Runner executes a single agent and returns an event stream; TurnLoop handles multi-turn runs with push, preempt, stop and checkpoint/resume. Middleware hooks into lifecycle points of the loop for things like context compression, tool search and retries. DeepAgents is a prebuilt agent that plans tasks and delegates to sub-agents.
• Composition: compose builds graphs, chains and workflows of nodes such as lambdas, chat models and tools. Graphs are compiled before running.

Besides ChatModelAgent, the ADK offers deterministic orchestration primitives: Sequential, Loop and Parallel workflow agents for predefined processes, and custom agents that implement the Agent interface. The docs frame graphs (deterministic orchestration) and agents (autonomous decision-making) as two different forms of AI application, and recommend ChatModelAgent when the core problem is autonomous decision-making plus runtime enhancement.

The docs explain a key design choice: rather than passing map[string]any between nodes as langchaingo does, Eino keeps each node's real input and output types and checks at compile time that upstream output can be assigned to downstream input. Options like WithOutputKey and WithInputKey convert to and from maps when several edges converge. A compiled graph can also be wrapped as a tool, so an agent can decide when to call a deterministic pipeline.

Key features

• Component ecosystem: abstractions for ChatModel, Tool, Retriever, Embedding, ChatTemplate and more, with official implementations for OpenAI, Claude, Gemini, Ark, Ollama, Elasticsearch and others in eino-ext.
• Automatic stream handling: the framework concatenates, boxes, merges and copies streams as data moves between nodes, so components only implement the streaming modes that make sense for them.
• Callback aspects: inject logging, tracing and metrics at OnStart, OnEnd, OnError and the streaming variants, across components, graphs and agents.
• Interrupt and resume: any agent or tool can pause for human input and resume from a checkpoint, with state persistence handled by the framework.
• Multi-agent patterns: sequential, loop and parallel workflow agents, supervisor and plan-execute examples, and DeepAgents for task decomposition.
• Graph tools: expose a composition as a tool with graphtool.NewInvokableGraphTool.

Getting started

The ADK quickstart installs the module with:

go get github.com/cloudwego/eino@latest

A minimal agent from the README configures a model and a runner, then iterates over events:

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?")

Tools are added through ToolsConfig, and the agent handles the ReAct loop internally. For deterministic flows, the README shows a typed graph:

graph := compose.NewGraph[*Input, *Output]()
graph.AddLambdaNode("validate", validateFn)
graph.AddChatModelNode("generate", chatModel)
graph.AddLambdaNode("format", formatFn)

graph.AddEdge(compose.START, "validate")
graph.AddEdge("validate", "generate")
graph.AddEdge("generate", "format")
graph.AddEdge("format", compose.END)

runnable, _ := graph.Compile(ctx)
result, _ := runnable.Invoke(ctx, input)

The FAQ adds two practical notes for production code. For structured output, ask the model for structured data (through a response-format setting where the model supports it, through tool calling, or through the prompt), then convert the message into your own struct with schema.NewMessageJSONParser. For reasoning models, if the model wrapper exposes thinking output, it is stored in the ReasoningContent field of the returned message. The FAQ also notes that versions after v0.6.0 no longer depend on the kin-openapi library, which removes a common source of type errors in older setups.

The eino-examples repository has complete programs for ChatModelAgent with interrupt and resume, DeepAgents, workflow agents and multi-agent setups.

Use cases

• Agents inside Go services: add a tool-using assistant to an existing Go backend without a separate Python runtime.
• RAG pipelines: compose loaders, embedders, retrievers and chat models into a typed graph; the docs' type-alignment examples compare direct chat against a RAG path.
• Human-in-the-loop workflows: pause an agent for approval and resume from a checkpoint.
• Research and coding agents: DeepAgents can coordinate specialised sub-agents and tools such as shell, Python execution and web search.
• Observability-heavy deployments: wire tracing and metrics through callback aspects at every node.
• Agent-callable pipelines: build a validation or data-processing graph with exact control flow, expose it as a tool, and let an agent decide when to run it, as the README demonstrates with a data_pipeline graph tool.

How it compares

The README names LangChain and Google ADK as influences, and the design docs contrast Eino with langchaingo's map[string]any approach. In practice, Eino's niche is Go teams that want compile-time-checked orchestration and built-in streaming. Python-first frameworks such as LangChain and LangGraph have larger ecosystems and more third-party integrations; if your stack is already Python, they are the more natural fit.

Things to know before adopting

• Pre-1.0 API: releases are in the v0.x series. The ADK quickstart says ADK has been available since v0.5.0 and recommends v0.9.0; expect API changes between minors.
• Documentation language: the README links the user manual and quick start to the Chinese docs; English pages exist on cloudwego.io but some content and the community group (Lark/Feishu) lean Chinese.
• Go version: the README lists Go 1.18 or newer. The FAQ notes that old versions of the bytedance/sonic dependency are incompatible with Go 1.24 and should be updated past v1.13.2.
• No built-in batch nodes: the FAQ says batch processing is not supported natively; it suggests building graphs per request or writing a custom batching node.
• Streaming tool-call detection: models differ in how they stream tool calls; the FAQ explains when to supply a custom StreamToolCallChecker.
• Security reports: go to ByteDance Security, not public GitHub issues.

Project activity

As of October 2026 the repository has about 13,400 stars and roughly 1,150 forks. It was created in December 2024, is written in Go and is licensed under Apache-2.0. The latest release at the time of writing is v0.9.22, published on 19 October 2026, and the main branch received commits the same week. Code is at github.com/cloudwego/eino, component implementations at github.com/cloudwego/eino-ext, and documentation at cloudwego.io/docs/eino.