1
react.NewAgent({ToolCallingModel, ToolsConfig}) → Stream/Generate
2
react.WithMessageFuture() → observe intermediate steps (no Callback needed)
3
host.NewMultiAgent({Host, Specialists}) → orchestration-style multi-Agent
4
Custom Graph + State → Plan-Execute / Deer-Go

1
User input → ChatModel thinks → Need to call a Tool?
2
                              ├─ Yes → Execute Tool → Tool result back to ChatModel → keep thinking
3
                              └─ No → Output final answer

1
import (
2
    "github.com/cloudwego/eino/flow/agent/react"
3
    "github.com/cloudwego/eino/compose"
4
)
5

6
rAgent, err := react.NewAgent(ctx, &react.AgentConfig{
7
    ToolCallingModel: arkModel,
8
    ToolsConfig: compose.ToolsNodeConfig{
9
        Tools: []tool.BaseTool{restaurantTool, dishTool},
10
    },
11
})
12

13
// Streaming call (same Recv+EOF pattern as ChatModel.Stream)
14
sr, _ := rAgent.Stream(ctx, []*schema.Message{
15
    schema.SystemMessage("You are an assistant that helps users find restaurants..."),
16
    schema.UserMessage("I'm in Beijing, recommend spicy dishes, at least 2 restaurants"),
17
})
18
defer sr.Close()
19

20
for {
21
    msg, err := sr.Recv()
22
    if errors.Is(err, io.EOF) { break }
23
    fmt.Print(msg.Content)
24
}

1
react.NewAgent(ctx, &react.AgentConfig{
2
    MessageModifier: func(_ context.Context, input []*schema.Message) []*schema.Message {
3
        return append([]*schema.Message{schema.SystemMessage(sys)}, input...)
4
    },
5
})

1
toolCallChecker := func(ctx context.Context, sr *schema.StreamReader[*schema.Message]) (bool, error) {
2
    defer sr.Close()
3
    for {
4
        msg, err := sr.Recv()
5
        if errors.Is(err, io.EOF) { break }
6
        if len(msg.ToolCalls) > 0 { return true, nil }
7
    }
8
    return false, nil
9
}

1
anyG, opts := rAgent.ExportGraph()
2
gen := visualize.NewMermaidGenerator("flow/agent/react")
3
g := compose.NewGraph[[]*schema.Message, *schema.Message]()
4
g.AddGraphNode("react_agent", anyG, opts...)
5
g.AddEdge(compose.START, "react_agent")
6
g.AddEdge("react_agent", compose.END)
7
g.Compile(context.Background(), compose.WithGraphCompileCallbacks(gen))

1
config := &AgentConfig{
2
    Model: am,
3
    ToolsConfig: compose.ToolsNodeConfig{
4
        Tools: []tool.BaseTool{summarizeTool, locationTool},
5
    },
6
    ToolReturnDirectly: map[string]struct{}{
7
        "summarize_news": {},  // ← summarize_news finishes execution and ends directly
8
    },
9
}

1
msg, _ := schema.ConcatAgenticMessages(msgs)
2

3
for _, block := range msg.ContentBlocks {
4
    switch block.Type {
5
    case schema.ContentBlockTypeReasoning:
6
        fmt.Printf("[Reasoning] %s\n", block.Reasoning.Text)
7
    case schema.ContentBlockTypeServerToolCall:
8
        fmt.Printf("[Server tool] %s\n", block.ServerToolCall.Name)
9
    case schema.ContentBlockTypeAssistantGenText:
10
        fmt.Printf("[Output] %s\n", block.AssistantGenText.Text)
11
    }
12
}

1
type MemoryStore interface {
2
    Write(ctx, sessionID string, msgs []*schema.Message) error
3
    Read(ctx, sessionID string) ([]*schema.Message, error)
4
    Query(ctx, sessionID, text string, limit int) ([]*schema.Message, error)
5
}

1
store := memory.NewInMemoryStore()
2
sessionID := "session:demo"
3

4
// Each conversation turn
5
prev, _ := store.Read(ctx, sessionID)                          // Restore history
6
eff := append(prev, schema.UserMessage(turn))                  // Concatenate new input
7
sr, _ := agent.Stream(ctx, eff, msgFutureOpt)                  // Execute
8
_ = store.Write(ctx, sessionID, append(eff, produced...))      // Persist

1
msgFutureOpt, msgFuture := react.WithMessageFuture()
2

3
// Consume the intermediate message stream
4
iter := msgFuture.GetMessageStreams()
5
for {
6
    sr, ok, _ := iter.Next()
7
    if !ok { break }
8
    full, _ := schema.ConcatMessages(readAllChunks(sr))
9
    fmt.Printf("Intermediate message: role=%s content=%s\n", full.Role, full.Content)
10
}

1
type ChatModel struct {
2
    Model         model.BaseChatModel
3
    GetOptionFunc OptionFunc  // ← Returns dynamic options based on State
4
}
5

6
func (d *ChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
7
    var dynamicOpts []model.Option
8

9
    compose.ProcessState[*State](ctx, func(_ context.Context, state *State) error {
10
        dynamicOpts = d.GetOptionFunc(ctx, input, state)
11
        state.Iteration++
12
        return nil
13
    })
14

15
    return d.Model.Generate(ctx, input, append(dynamicOpts, opts...)...)
16
}

1
func getDynamicOptions(ctx context.Context, input []*schema.Message, state *State) []model.Option {
2
    if state.Iteration >= 1 {
3
        // From the second round on: disable thinking, forbid Tool calls
4
        return []model.Option{
5
            ark.WithThinking(&arkModel.Thinking{Type: arkModel.ThinkingTypeDisabled}),
6
            model.WithToolChoice(schema.ToolChoiceForbidden),
7
        }
8
    }
9
    // First round: allow Tool calls
10
    return []model.Option{
11
        model.WithToolChoice(schema.ToolChoiceAllowed),
12
        model.WithTools(toolInfos),
13
    }
14
}

1
rAgent, _ := react.NewAgent(ctx, &react.AgentConfig{
2
    ToolsConfig: compose.ToolsNodeConfig{
3
        Tools: []tool.BaseTool{sumTool},
4
        UnknownToolsHandler: func(ctx context.Context, name, input string) (string, error) {
5
            return fmt.Sprintf(
6
                "unknown tool: %s; try again with the correct tool name", name,
7
            ), nil
8
        },
9
    },
10
})

1
User → Host (analyze intent)
2
         ├─ "Write journal" → WriteJournalSpecialist
3
         ├─ "Read journal" → ReadJournalSpecialist
4
         └─ "Query journal" → AnswerWithJournalSpecialist

1
import "github.com/cloudwego/eino/flow/agent/multiagent/host"
2

3
h := &host.Host{ChatModel: chatModel, SystemPrompt: "..."}
4

5
hostMA, _ := host.NewMultiAgent(ctx, &host.MultiAgentConfig{
6
    Host: *h,
7
    Specialists: []*host.Specialist{writer, reader, answerer},
8
})
9

10
// Multi-turn conversation
11
out, _ := hostMA.Stream(ctx, []*schema.Message{schema.UserMessage(input)},
12
    host.WithAgentCallbacks(cb),  // Can listen to HandOff events
13
)

1
Planner → Executor ⇄ Reviser
2
                             ↓
3
                    Output "final answer" → END

1
config := &Config{
2
    PlannerModel:  deepSeekModel,    // Planner model
3
    ExecutorModel: arkModel,         // Executor model (must support ToolCalling)
4
    ReviserModel:  deepSeekModel,    // Reviser model
5
    ToolsConfig:   compose.ToolsNodeConfig{Tools: toolsConfig},
6
    MaxStep: 100,
7
}

1
for {
2
    result, err := agent.Invoke(ctx, input,
3
        compose.WithCheckPointID("1"),
4
        compose.WithRuntimeMaxSteps(20),
5
    )
6

7
    info, ok := compose.ExtractInterruptInfo(err)
8
    if ok {
9
        // Interrupted — show the result, wait for user confirmation
10
        fmt.Print("Do you want to continue? (y/n): ")
11
        // ... read user input ...
12
        continue  // Auto Resume
13
    }
14
    fmt.Printf("[FinalResult]: %s", result)
15
    break
16
}

1
// Command-line tool (Docker sandbox)
2
sandbox.NewDockerSandbox(ctx, &sandbox.Config{...})
3

4
// Browser tool
5
browseruse.NewBrowserUseTool(ctx, &browseruse.Config{...})
6

7
// Search engine
8
duckduckgo.NewSearch(ctx, &duckduckgo.Config{...})

1
func agentHandOff(ctx context.Context, input string) (next string, err error) {
2
    compose.ProcessState[*model.State](ctx, func(_ context.Context, state *model.State) error {
3
        next = state.Goto
4
        return nil
5
    })
6
    return next, nil
7
}
8

9
// All Agent nodes share the same Branch function
10
g.AddBranch(consts.Coordinator, compose.NewGraphBranch(agentHandOff, outMap))
11
g.AddBranch(consts.Planner, compose.NewGraphBranch(agentHandOff, outMap))

1
Coordinator → BackgroundInvestigator → Planner → ResearchTeam
2
                                                      ├─→ Researcher
3
                                                      ├─→ Coder
4
                                                      └─→ Planner (iterate)
5
                                                           └─→ Reporter → Human → Coordinator

1
// ReAct Agent
2
"github.com/cloudwego/eino/flow/agent/react"           // react.NewAgent, WithMessageFuture
3

4
// Multi-Agent
5
"github.com/cloudwego/eino/flow/agent/multiagent/host"  // host.NewMultiAgent, Host, Specialist
6

7
// Compose low-level
8
"github.com/cloudwego/eino/compose"                     // Graph, Branch, ProcessState, ToolNode
9
"github.com/cloudwego/eino/schema"                      // Message, AgenticMessage, ToolInfo
10

11
// Callbacks
12
"github.com/cloudwego/eino/callbacks"                   // Handler, HandlerBuilder
13
"github.com/cloudwego/eino/utils/callbacks"              // NewHandlerHelper

1
Flow module core methods:
2
  react.NewAgent({ToolCallingModel, ToolsConfig})
3
  host.NewMultiAgent({Host, Specialists})
4
  compose.NewGraphBranch(fn, outMap)
5
  compose.ProcessState[T](ctx, fn) — read/write Graph State
6

7
Selection: Standard→ADK | Custom loop→react | Multi-Agent dispatch→host | State graph→Graph+State