JetBrains/koog

Features

• AI Agent Orchestrators - Provides a comprehensive system for organizing and coordinating specialized agents using structured workflows and tool interactions.
• Agentic Workflow Graphs - Implements agent behaviors as directed graphs of tasks and state transitions to orchestrate complex workflows.
• Autonomous Agent Orchestration - Provides a framework for designing and deploying autonomous agents that execute complex workflows via directed graphs.
• Model Provider Management - Provides a central orchestrator for managing multiple LLM providers with dynamic switching and unified execution.
• Long-term Memory Stores - Provides persistent storage mechanisms for agents to recall information and context across different sessions.
• Agent State Persistence - Saves and restores the full execution state of autonomous agents to enable session recovery and rollbacks.
• Agentic LLM Frameworks - Provides a comprehensive framework for building autonomous agents that combine LLMs with tool-based workflows and memory.
• Agentic Reasoning Loops - Implements iterative loops where the agent alternates between reasoning and tool execution to process complex tasks.
• Agentic State Machines - Models agent logic as a state machine where nodes represent actions and edges control the flow of data.
• Stateful Workflow Persistence - Stores and updates data across multiple executions of a single node using thread-safe wrappers for state persistence.
• Conversational AI Agents - Provides a framework for building agents that engage in interactive, human-like dialogue to assist users and perform tasks.
• Agent Persona Definitions - Allows the definition of specific system prompts and behavioral constraints to establish agent personas and operational identities.
• Agent Tool Execution - Executes one or multiple tool calls requested by the model, including support for parallel execution.
• Model Provider Integrations - Interchanges different AI model backends using a unified API without altering core business logic.
• Tool Orchestration - Coordinates the definitions and execution flows of tools between language models and clients.
• MCP Server Connections - Establishes connections to context protocol servers using stdio or SSE transports to retrieve remote tools.
• AI Observability Tracing - Captures execution traces of agent decisions and model interactions using OpenTelemetry spans.
• LLM Tooling Integrations - Connects language models to external APIs and custom functions to enable agents to perform technical tasks.
• Model Request Orchestrators - Manages the execution of prompts to model providers, including streaming and content moderation.
• Conversation Memory Managers - Implements systems for storing and retrieving interaction history to maintain context across multi-turn dialogues.
• Conversation Flow Design - Uses a structured builder to define the sequence and logic of system and user messages in a conversation.
• Retrieval-Augmented Generation - Implements a RAG memory system using vector embeddings to provide agents with domain-specific knowledge.
• Conversational Memory Systems - Implements a RAG memory system using vector embeddings to maintain long-term conversational context.
• LLM Context Preparation - Prepares the conversation context by adding system instructions and user messages before making requests.
• External Tool Integration - Implements capabilities for agents to interact with external APIs and systems to perform technical tasks.
• MCP Protocol Integrations - Connects agents to external tool registries using the Model Context Protocol via SSE transports.
• Chaining Pipelines - Chains multiple language model requests where the output of one serves as the context for the next.
• Tool Result Aggregators - Processes outputs from executed tools and reintegrates them into the model context for follow-up responses.
• Hierarchical Agent Orchestration - Implements a coordinator agent that manages specialized worker agents to handle multi-domain requests.
• Agent-as-Tool Wrapping - Allows agents to be converted into tools, enabling a nested hierarchical architecture for complex task delegation.
• Model Context Protocol Implementations - Implements the Model Context Protocol to connect agents to remote tool servers for standardized tool access.
• Model Output Formatting - Enforces structured data schemas to ensure model responses are in a machine-readable format.
• Multi-Provider Abstractions - Provides a unified interface to manage multiple AI providers with support for dynamic switching and automatic fallbacks.
• Prompt Orchestration - Defines and executes the core prompts that drive interactions between the agent and the language model.
• RAG Context Retrieval - Implements retrieval augmented generation to recall relevant information from vector embeddings across sessions.
• RAG Knowledge Management - Implements a RAG-based memory system using vector embeddings to maintain long-term conversation context across sessions.
• Tool Function Registrations - Binds a set of available functions to an agent, enabling it to select and execute tools dynamically.
• Model-Response Routing - Determines the path between graph nodes based on the type of language model response received.
• Conditional Branching - Directs workflow execution paths based on dynamic evaluation of state or tool call detections.
• Unified Model Interfaces - Provides a standardized execution interface that abstracts different cloud-based and local language model providers.
• Business Logic Nodes - The library defines reusable processing steps with specific input and output types to execute custom business logic.
• Agent - Creates functions with descriptors and type-safe definitions that provide models with metadata to execute external actions.
• Sequential Agent Execution - Designs sequential subgraphs of nodes and edges to control linear processing of input by agents.
• Agent Communication Protocols - Uses a consistent protocol of methods and message formats to standardize interaction between agents and clients.
• Agent Client Protocols - Standardizes communication between agents and clients by mapping internal states to protocol blocks.
• Agent Deployment - Initializes and provisions autonomous agent instances by connecting language models to prompt executors.
• JVM Backend Integrations - Embeds agent functionality into existing JVM-based applications through compatibility with common backend frameworks.
• Tool-Based Knowledge Retrievers - Exposes document retrieval systems as tools that agents can invoke on demand for knowledge retrieval.
• Node-Level State Transformations - Converts the output of one graph node to match the input type of the next node via state transformations.
• Parallel Tool Execution - Enables the concurrent execution of multiple tools by an agent to accelerate data gathering.
• Filesystem Tooling - Provides tools for agents to perform read, edit, and write operations on the local filesystem.
• Context Trimming - Provides capabilities to reduce token consumption by filtering and trimming conversation history to fit model windows.
• Provider Switching - Changes the active model and toolset mid-conversation while rewriting history to maintain continuity.
• Chat Message Formats - Organizes instructions using rich text or structured data formats within chat messages.
• Context Compression - Reduces the size of message history to prevent exceeding LLM context window limits during long interactions.
• Conversation History Management - Reduces token consumption by replacing detailed conversation history with concise summaries based on defined strategies.
• Conversation History Extensions - Builds new prompts by appending messages to previous conversations to maintain interaction continuity.
• Execution Interception Hooks - Implements hooks to observe or modify behavior during model calls and agent startup.
• Generation Temperature Controls - Controls creativity and determinism by adjusting the temperature parameter for focused or diverse outputs.
• Human-in-the-Loop Workflows - Implements mechanisms for integrating manual human approvals and interventions into automated agent decision processes.
• Incremental Inference Streaming - Streams model outputs incrementally, including text deltas and reasoning steps, for real-time processing.
• Model Parameters - Adjusts randomness, token limits, and output diversity through model parameters to control behavior.
• Provider-Specific Configurations - Provides advanced configuration options to access provider-specific features like reasoning effort and prompt caching.
• Iterative Response Correction - Uses an auxiliary model to iteratively fix parsing errors until responses conform to the required schema.
• Model Fallbacks - Automatically redirects requests to a secondary AI provider when the primary client is unavailable.
• Agent Response Streams - Streams real-time updates on model responses and tool call lifecycles via an asynchronous event producer.
• Multimodal Input Processors - Ingests and processes diverse data types including text, images, audio, and video for model reasoning.
• OpenTelemetry Exporters - Exports agent lifecycle events and model interactions as traces using the OpenTelemetry protocol.
• Prefix Caching - Instructs providers to store prompt prefixes on the server to optimize repetitive workloads.
• Reasoning Capture Utilities - Extracts incremental reasoning text and summaries to reveal the agent's internal thought process.
• Provider Failover Handlers - Sends prompts to multiple different model providers to implement fallback logic and ensure reliability.
• Structured Prompting Tools - Uses a specialized language to organize system instructions and formatted markdown for consistent prompt structure.
• Invocation Control Strategies - Allows specifying whether the model should automatically choose tools, use a specific tool, or avoid tool use.
• Visual Content Analysis - Analyzes and extracts insights from image and video content to enable vision-based reasoning.
• Tool Registries - Manages central registries that map tool identifiers to implementations for lookup and invocation by name.
• Agent Operation Tracking - Tracks and stores the state, history, and artifacts of long-running operations to provide progress updates.
• Custom Functional Node Development - Supports the creation of specialized functional blocks within a workflow to transform data or interact with models.
• LLM Schema Outputs - Enforces structured JSON outputs from models using schemas and an auxiliary model to correct parsing errors.
• Conversation History Backends - Integrates pluggable storage backends for persisting and loading conversation records across application restarts.
• Response Caching - Caches previously executed prompt results to reduce latency and operational costs.
• Agent-Specific Query Routing - Directs user inputs to specific tools or sub-agents using semantic intent and graph-based routing patterns.
• State Checkpointing - Saves and restores full execution state and conversation history to enable session recovery and rollbacks.
• Type-Safe State Stores - Passes information using a type-safe key-value system to maintain data integrity across different nodes or subgraphs.
• Protocol Endpoint Hosting - Exposes a protocol-compliant endpoint to receive requests, process tasks, and return status updates.
• Context Compression - Reduces token consumption by specifically compressing results from tool executions in the conversation history.
• Agent Workflow Interception - Provides middleware hooks to intercept and modify the steps of an agent's reasoning loop.
• Runtime Prompt Modifiers - Alters the current prompt object during a session to add, remove, or reorder messages.
• MCP Transport Protocol Supports - Supports multiple communication methods for client interaction, including JSON-RPC over HTTP and SSE.
• Structured Object Streaming - Performs incremental parsing of structured data objects as they are streamed from the model.
• Error Recovery - Hooks into workflow failure events to execute custom error recovery and handling logic.
• Workflow Subgraph Packaging - Provides the ability to group functional nodes into reusable subgraph components for hierarchical logic structures.
• Multiplatform Agent Runtimes - Runs agent logic on multiple targets using a single multiplatform codebase.
• Performance and Reliability - Ensures runtime reliability through built-in retries and state restoration from persistence checkpoints.
• Parallel Execution - Executes multiple workflow nodes concurrently to improve performance and aggregate results from parallel paths.
• OpenTelemetry-Integrated Monitors - Integrates OpenTelemetry to capture agent lifecycle events and model interactions as spans for external tracing.
• GenAI Execution Monitoring - Tracks GenAI-specific metrics such as token usage and tool call counts using standard conventions.
• Browser Automation - Provides capabilities to drive web browsers programmatically for executing tasks and capturing interactions.

Star history