Exposes retrieval as a Tool, not as an augmenter

Builds an embedder from a provider

Builds a vector store and indexes documents

Adds the RAG and embeddings dependencies

Registers the search tool with the agent's ToolRegistry

Search tool returns formatted results, not raw vector hits

Installs the Koog Ktor plugin

Adds the koog-ktor dependency

Configures the prompt executor inside the install block

Reads the OpenAI API key from the environment

Adds a POST /agent route

Resolves the agent from the plugin attribute

Uses A2AClient to call the remote

Adds a2a-core and a2a-client dependencies

Wraps the A2A call inside a tool

Reads the bearer token from the environment

Registers the wrapper tool with the agent

Adds the agents-features-opentelemetry dependency

Installs OpenTelemetry in the trailing lambda

Calls addLangfuseExporter inside the install block

Sets langfuse.session.id from the environment

Turns on verbose mode

Does not stack a second backend integration

Calls replaceHistoryWithTLDR inside llm.writeSession

Compresses only at the boundary node, not every node

Picks WholeHistory or equivalent TL;DR strategy

Does not introduce LongTermMemory

Compression happens before the next LLM call in drafting

Installs the Trace feature

Adds the agents-features-trace dependency

Captures EDGE_EVALUATION events

Captures NODE_ENTRY events

Sends trace to a local sink

Uses Attachment.image to wrap the file

Constructs a Message.User with attachments

Sends via nodeLLMSendMessage, not nodeLLMRequest

Strategy is typed strategy<File, String>

Returns text from a final nodeFinish edge

PDF via Attachment.file

Image via Attachment.image(url)

Anthropic model with PDF support

No manual file encoding

Both attachments in one Message.User

Runtime attachment construction in node body

Sends via nodeLLMSendMessage

Uses AIAgentService.fromAgent to wrap the find agent

Calls createAgentTool with typed input/output

Provides agentDescription and inputDescription for the LLM

Preserves the find agent's separate configuration

Registers the wrapped tool in the main agent's ToolRegistry

Does not introduce a strategy graph or subgraph

Picks the LLM-based planner primitive

Adds the separate planner module dependency

Passes the planner as the strategy parameter

Sets a much higher maxIterations than the default

Includes the lookup tools in the registry

Uses top-level AIAgent factory

Installs the ACP feature

Adds the agents-features-acp dependency

Makes the long-running tool honor cancellation

Notes that catching CancellationException would defeat cancel

Mentions the example or feature module's API

Does not block on coroutine internals

Installs the Sql feature in read-only mode

Scopes the schema to the named tables

Caps result rows

Reads DB credentials from environment

Pins schema in system prompt

Adds the agents-features-sql dependency and JDBC driver

Uses the functional-agent factory

Strategy block is a single suspending block

Trims the LLM response inside the block

Includes the system prompt for formal-English rewriting

Reads OPENAI_API_KEY from environment

No tools registered

Adds agents-test as testImplementation

Uses a scripted/mocked prompt executor

Records tool-call sequence via handleEvents

Asserts ordering — lookup_priority before classification

Tools run their real implementations

Single agent.run call per test

Configures both providers under ai.koog.<provider>

Reads both keys from environment variables

Migrates service code from LLMClient to MultiLLMPromptExecutor

Routes by model at the call site

Does not introduce a custom @Bean LLMClient override

Does not remove the starter dependency

Picks the annotated ToolSet style

Annotates parameters with @LLMDescription

Annotates the class and method with @LLMDescription

Registers via ToolRegistry DSL

Passes the registry into AIAgent at construction

Does not introduce typed args classes

Uses subgraphWithTask and subgraphWithVerification

Conditional edge from verify drives the loop

Fix loops back to verify

Each subgraph has its own tools set

Verifier uses a cheaper model than fixer

Top-level strategy<Input, Output>(name) declaration

Uses cacheControl on the system segment

Mentions Anthropic minimum-token requirement

Places the breakpoint at end of system content

Uses the prompt DSL builder

References observability for cache-hit verification

Does not change the agent's model

Uses nodeLLMRequestStreaming

Supplies a chunk handler lambda

Names that the handler must not block

Wires the streaming node into a top-level strategy<...>

Does not include tool nodes

Installs the Tokenizer feature

Sets a 50000 runBudget

Picks BudgetAction.CompressHistory

Adds the tokenizer dependencies

Does not lower the model to a cheaper one

Notes how the cap surfaces in observability if installed

Uses the prompt { ... } DSL builder

System turn names the classification task

Each example is a user/assistant pair

Examples are inline literal strings

Imports prompt builder from ai.koog.prompt.dsl

Does not introduce a PromptAugmenter

Installs the Persistence feature

Adds the JDBC persistence backend dependency

Configures the backend with the JDBC connection

Uses Persistence type names, not Persistency

Shows resume path with runFromCheckpoint

Notes serializability requirement for storage

Uses 1.0+ umbrella coordinate

Targets JDK 17 toolchain

Uses top-level AIAgent factory

Reads API key from environment

Wires simpleOpenAIExecutor and a current OpenAI model

Omits the default singleRunStrategy

Runs the agent inside runBlocking

Initializes git in the new directory

Application plugin wired with mainClass

Installs the Snapshot feature

Adds the agents-features-snapshot dependency

Calls snapshot() at the decision point

Demonstrates two runFromSnapshot calls

Notes serializability requirement

Replaces AgentMemory with LongTermMemory

Renames queryExtractor and extractionStrategy

Removes IngestionTiming

Drops .invoke from the AIAgent call

Adds the new LongTermMemory dependency

Bumps JDK target to 17

Updates all Koog coordinates to 1.0+

Uses PlannerNode.parallel inside PlannerNode.sequential

Builds the agent with PlannerAIAgent / Planners.*

Tracks current subtask via storage key

Adds the planner module dependency

Sets maxIterations well above the default

Does not over-engineer with graph subgraphs

Uses simpleAnthropicExecutor

Selects a current Anthropic model

Reads ANTHROPIC_API_KEY from the environment

Accepts the existing-empty-directory state without overwrite

Uses 1.0+ umbrella coordinate

Top-level AIAgent factory call

Installs the JDBC chat-history feature

Adds the JDBC chat-history dependency

Reads DB credentials from environment

Threads userId as sessionId on agent.run

Does not require user to thread message history manually

Subclasses Tool<TArgs, TResult>

Declares a ToolDescriptor

Implements suspend execute(args) returning the typed result

Registers with the ToolRegistry DSL

Reuses the existing @Serializable data classes

Does not introduce a ToolSet wrapper

Composes the two registries with +

Preserves the existing CalculatorTools registration

Uses the modern HTTP MCP transport

Adds the agents-mcp dependency

Constructs the merged registry before AIAgent(...)

Calls the suspending MCP builder inside a coroutine context

Imports the `onToolCalls` extension explicitly

Imports the `onTextMessage` extension explicitly

Does not invent a member import for `forwardTo`

Uses both edge primitives the loop needs

Chains `nodeExecuteTools` to `nodeLLMSendToolResults` explicitly

Wires the loop back through `nodeExecuteTool` on continued tool calls

Picks the SSE transport

Imports the `fromSseUrl` extension explicitly

Pins the MCP artifact to `1.0.0-beta`

Uses the `-jvm` suffix on the artifact

Builds the registry before constructing the agent

Calls the suspending builder inside a coroutine context

Uses the Streamable HTTP transport

Adds the agents-mcp dependency

Passes the server URL to the transport configuration

Builds the registry before constructing the agent

Calls the suspending builder inside a coroutine context

Reads the GitHub token from the environment

Passes the token as a bearer header in the transport config

Uses the process-based MCP transport

Launches the process with ProcessBuilder

Adds the agents-mcp dependency

Builds the registry before constructing the agent

Calls the suspending builder inside a coroutine context

Does not import Ktor or HTTP-client types

Tools sliced into communication / read / write ToolSets

Each phase grants only the matching tool subset

Typed @LLMDescription'd data classes for inter-phase handoffs

Uses subgraphWithTask<In, Out> for each phase

Verification + adjust loop with CriticResult branching

Mixed model selection per phase

Declares the required Gradle dependencies

Installs the event-handler feature

Adds the agents-features-event-handler dependency

Subscribes to onToolCallStarting

Subscribes to onToolCallFinished

Uses distinct visual markers for start vs end

Does not also install OpenTelemetry

Calls startStdioMcpServer

Adds the agents-mcp-server dependency

Wraps the existing ToolSet in a ToolRegistry

Keeps the process alive after startup

Does not reach for the client transport surface

Routes tool results through an explicit send-results node

Adapts the LLM client to the decoupled HTTP transport

Swaps kotlin.time.Clock for KoogClock

Raises the JDK and Kotlin toolchain minima

Drops .invoke from the AIAgent construction

Bumps all Koog coordinates to 1.0 with no mixed versions

Chooses ACP for the tooling-client case

Adds the ACP dependency

Correct ACP import

install(ACP) in the AIAgent trailing lambda

Configures the endpoint inside install(ACP)

Notes progress events surface to the client

Rationale for ACP over A2A

Distinguishes caller-triggered from continuous save

Routes to the Persistence feature

Does NOT recommend installing the snapshot feature

Acknowledges the developer's word choice without capitulating

Mentions the cost of frequent checkpoints

Detects the non-empty state before writing

Refuses to proceed without explicit confirmation

Asks an explicit yes/no overwrite question

Names what would be overwritten

Leaves the directory unchanged on refusal

Names the topology as the disqualifying signal

Redirects to the graph DSL

Does not install agents-planner

Acknowledges the developer's framing without capitulating

Mentions the cost penalty of an unwarranted planner

Identifies the three persistence layers in Koog

Routes to chat-history-jdbc

Does NOT install the generic Persistence feature

Acknowledges the developer's word choice without capitulating

Does NOT recommend LongTermMemory

Uses responseProcessor on the factory

Parameterizes AIAgent with the typed Output

Reuses the developer's data class verbatim

Drops the regex parsing

Does not introduce a custom strategy

Names the absence of distinct phases as the disqualifier

Redirects to the simpler shape

Does not produce subgraphWithTask code

Does not introduce typed handoff data classes

Engages with the developer's framing without capitulating

Names the cache-vs-response distinction

Recommends the provider-side caching path

Does not wrap the executor in an in-process cache

Acknowledges the framing without capitulating

Mentions Anthropic's minimum-token requirement

Does not install JdbcChatHistory / chat-history-jdbc

Recommends LongTermMemory or a Tool

Does not synthesise pseudo-turns into a custom ChatHistoryProvider

Names the chat-history-vs-fact-store distinction