In a Koog strategy, what do nodeStart and nodeFinish define?

## The boundary, not a step `nodeStart` and `nodeFinish` are supplied inside every `strategy { }` block. It helps to stop thinking of them as nodes that execute something and start thinking of them as the graph's *signature*. `nodeStart` hands the strategy's input to the first real node. `nodeFinish` accepts the value that becomes the agent run's result. Nothing else happens at either end. Concretely: whatever you pass to `agent.run(...)` arrives as `nodeStart`'s output, and whatever reaches `nodeFinish` is what `run` returns to your Kotlin code. ## Typing the graph `strategy("name") { ... }` gives you the common case, a `String` in and a `String` out. The generic form, `strategy<TInput, TOutput>("name") { ... }`, lets you declare your own types — a data class in, a data class out — and the whole graph is then checked against them. That matters because every node in Koog carries an input and an output type too. `nodeLLMRequest()` accepts the strategy input and produces a model response. `nodeExecuteTool()` accepts a tool call and produces a tool result. A custom `node<In, Out>("name") { input -> output }` declares whatever you like. An `edge(a forwardTo b)` compiles only when `a`'s output type is acceptable as `b`'s input type. Wire a tool result into a node expecting the strategy input and you get a compile error in the IDE, not a runtime failure in production. This is the concrete meaning of "type-checked control flow", which is the main thing Koog trades on for JVM teams: on a dynamically typed agent framework the same mistake is discovered when the graph actually reaches that hop, possibly in production, possibly after money has been spent on model calls. ## transformed: bridging the gap Types will not always line up, and that is expected. An edge can carry a transformation: `transformed { }` maps the upstream node's output into the shape the downstream node wants — pulling text out of a model response, wrapping a tool result in a domain object, or projecting a data class down to the `String` a default-typed `nodeFinish` accepts. Combine it with a condition and the edge both filters and converts. The discipline point: `transformed` is for adapting shapes, not for hiding logic. A transform that quietly performs a business decision is control flow smuggled onto an edge, where it is harder to see and harder to test than a named node doing the same work. ## One entry, many exits The asymmetry is worth stating explicitly. `nodeStart` has no incoming edges — there is exactly one way into the graph. `nodeFinish` has no outgoing edges, but it may have many incoming ones, and normally does: the model answered without tools; the model answered after tools; a validation node gave up; a guard rejected the request. Each incoming edge is one termination path, and reviewing that set is the fastest way to reason about how a strategy can end. Inside a subgraph, `nodeStart` and `nodeFinish` refer to *that subgraph's* own boundary, not the outer strategy's. This is what makes a subgraph composable: it looks like a node from the outside, with its own input and output types, and its internal start and finish are local. ## The failure the compiler cannot see Types tell you a hop is legal. They tell you nothing about reachability. A graph where some node's outgoing conditions can all be false has a hole: at runtime the run reaches that node, matches nothing, and cannot advance to `nodeFinish`. Nothing in the type system objects. This is why `maxIterations` on the agent is not optional in spirit — it is the backstop for logical gaps that typing structurally cannot catch, and why reviewing a strategy means tracing every node's exits, not just checking it compiles. ## How to talk about it The crisp answer is: they are the strategy's input and output types made explicit as graph endpoints, they give the run a compile-checked signature, and the number of edges into `nodeFinish` is the number of ways the agent can end. Then note the limit — typing proves the wiring is legal, not that it terminates.