In a Koog strategy graph, which edges close the LLM tool-calling loop?

## The three nodes Koog ships the tool loop as three predefined node builders, used as delegated properties inside `strategy("name") { }`: - `nodeLLMRequest()` — takes the input, appends it to the prompt, calls the model, and outputs the model's response. - `nodeExecuteTool()` — takes a tool call from that response, looks the tool up in the agent's registry, executes it, and outputs the result. - `nodeLLMSendToolResult()` — takes a tool result, appends it to the conversation, calls the model again, and outputs the new response. Notice the shape: the two LLM nodes both emit a model response that may be *either* a tool call or a plain assistant message. That is the whole reason the loop needs conditional edges. ## The wiring ``` nodeStart -> callLLM callLLM --onAssistantMessage--> nodeFinish callLLM --onToolCall---------> runTool runTool ----------------------> sendResult sendResult --onAssistantMessage--> nodeFinish sendResult --onToolCall---------> runTool ``` In DSL form each line is an `edge(a forwardTo b)` with an optional condition block, `onToolCall { true }` or `onAssistantMessage { true }`. The condition lambda receives the node's output, so you can be selective — `onToolCall { it.tool == "search" }` routes only one tool somewhere special — but `{ true }` is the normal catch-all. ## Where the cycle actually is The cycle is not `callLLM -> runTool -> callLLM`. `nodeLLMRequest` appends a *user* turn to the prompt; re-entering it mid-loop would corrupt the conversation. The cycle is `runTool -> sendResult -> runTool`: the send-result node is the one that keeps calling the model with accumulated tool output. `nodeLLMRequest` is entered once, from the start. This is the single most common wiring mistake to talk about in an interview: candidates draw the loop back to the request node because that is how they picture a ReAct cycle abstractly, and the resulting agent either re-asks the original question every turn or fails to type-check, because `nodeLLMRequest` expects the strategy's input type, not a tool result. ## Both exits matter Every node that can emit an assistant message needs an edge out to `nodeFinish`. Beginners wire the exit on `callLLM` — the case where the model answers without touching a tool — and forget it on `sendResult`, which is the case that fires on *every* successful tool run. The result is an agent that answers trivial questions fine and hangs on anything that uses a tool, until `maxIterations` aborts it. When someone reports "my Koog agent works until it calls a tool", this is the first thing to check. ## Multiple tool calls in one turn Modern models often return several tool calls in a single response. `nodeExecuteTool` handles one call; Koog also provides the plural variants (`nodeExecuteMultipleTools`, `nodeLLMSendMultipleToolResults`) and a matching multiple-tool-call edge condition for that shape. The loop topology is identical — request, execute, send results, branch — only the arity changes. If your model provider returns parallel calls and you wired only the singular nodes, you will see calls dropped or the graph failing to match an edge. ## Edge conditions are checked, not guessed `onToolCall` and `onAssistantMessage` are not magic strings; they are typed conditions over the node's output, and the compiler enforces that the downstream node accepts what the edge produces. That is Koog's pitch: this whole loop is a compile-time-checked object graph, so a mistyped hop is a build error. What the compiler cannot catch is a *logical* gap — a node whose conditions never all match, or a missing exit — and that is what `maxIterations` exists to bound. ## Practical shape Once you have written this loop twice, you realise it is exactly what Koog's default agent does for you. The reason to spell it out is to insert something into it: a validation node between tool execution and the model, a history-compression node once the transcript grows, or a branch that routes an expensive tool through a human approval step. The loop above is the skeleton you graft those onto.