embabel/embabel-agent

This system is the Embabel Agent Framework, a comprehensive platform for building, orchestrating, and deploying autonomous AI agents. It provides a structured API for defining agent goals, tools, and workflows, supporting complex planning strategies like GOAP and utility-based selection. The framework integrates with numerous LLM providers, manages state via a blackboard, and includes infrastructure for human-in-the-loop interactions, observability, and secure execution.

165 changes.

This period established the foundational architecture of the Embabel Agent Framework, introducing the core API for agent execution, goal-oriented planning (GOAP), and human-in-the-loop interactions. It implemented essential infrastructure including multimodal support, workflow builders, and a comprehensive set of tools for file, code, and math operations. The work also integrated the platform with Spring AI 2.0 and added auto-configuration for major LLM providers like OpenAI, Anthropic, and AWS Bedrock.

88 changes.

This period focused on hardening the agent platform with robust persistence, observability, and streaming capabilities. Key developments included introducing durable process snapshots for Human-in-the-Loop workflows, implementing comprehensive OpenTelemetry tracing, and establishing a vendor-neutral streaming architecture. The work also expanded provider support, refined tool orchestration with progressive disclosure, and added safety guardrails to ensure reliable agent execution.

Users can now programmatically request graceful early termination of an agent process or a specific action via new extension functions on ProcessContext. The terminateAgent function stops the entire agent, while terminateAction stops only the current action, both accepting a human-readable reason. Additionally, the system now supports an internal termination signal policy that checks for API-driven termination requests, allowing external callers to interrupt ongoing agent operations based on scope (agent-level or action-level).

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/termination · high confidence

Users can now explicitly define the expected format of an agent's text response through the new ResponseFormat component. This feature introduces a PromptContributor that appends a specific instruction block to prompts, with built-in constants for Markdown and HTML formats to ensure consistent output styling.

embabel-agent-api/src/main/kotlin/com/embabel/agent/prompt · high confidence

Users can now use Alibaba Cloud DashScope Qwen models (Qwen3.7-Max, Qwen3.7-Plus, and Qwen3.7-Flash) within the Embabel Agent system. This change introduces a new Spring Boot auto-configuration module that registers these models as LLM services when the DashScope API key is provided via the DASHSCOPE\_API\_KEY environment variable or the embabel.agent.platform.models.dashscope.api-key property. The models are loaded from a default YAML configuration file and are served through DashScope's OpenAI-compatible API endpoint. The implementation includes parameter clamping for temperature (0.0 to 1.99) and top\_p (0.01 to 1.0) to ensure compatibility with DashScope's API requirements, and includes unit and integration tests to verify bean registration and basic model functionality.

embabel-agent-autoconfigure/models/embabel-agent-dashscope-autoconfigure · high confidence

The platform now supports Z.ai (Zhipu AI) GLM models, automatically registering beans for GLM-5.2, GLM-4.7, GLM-4.6, GLM-4.5-Air, and GLM-4.7-Flash when the ZAI\_API\_KEY environment variable is set. These models are served via an OpenAI-compatible endpoint and include per-token pricing metadata. The configuration enforces GLM-specific constraints, such as clamping the sampling temperature to the required (0.0, 1.0\] range, and includes tests to verify model registration and live API connectivity.

embabel-agent-autoconfigure/models/embabel-agent-zai-autoconfigure · high confidence

The system now includes a new Spring Boot autoconfiguration class for AWS Bedrock models. This change imports the Bedrock model configuration and registers a shared, primary ToolCallingManager bean. This ensures compatibility with Spring AI 2.0's Bedrock proxy-chat auto-configuration, which requires a ToolCallingManager instance to wire up correctly alongside Embabel's model beans.

embabel-agent-autoconfigure/models/embabel-agent-bedrock-autoconfigure/src/main/java · high confidence

A new \OutputChannelHighlightingEventListener\ has been introduced to provide users with real-time visibility into agent operations. This listener monitors \ToolCallRequestEvent\ and \LlmRequestEvent\ instances, sending progress updates to the output channel. It specifically suppresses raw input details for \CommunicateTool\ and \ProgressTool\ calls to avoid cluttering the user view with internal communication artifacts, while still displaying the tool name and, if verbose mode is enabled, the input arguments for other tools. It also reports when an LLM is being called, including the name of the LLM service.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/event/progress · high confidence

The Anthropic integration now uses Spring Boot auto-configuration to automatically discover and register Anthropic models defined in a YAML file (defaulting to \classpath:models/anthropic-models.yml\). This allows users to declare model metadata—such as model IDs, thinking mode budgets, and pricing—without manual bean wiring. The configuration also exposes \embabel.agent.platform.models.anthropic\ properties for API keys and base URLs, and adds extension functions to expose Anthropic-specific usage metrics like cache creation and read tokens in the standard usage object.

embabel-agent-autoconfigure/models/embabel-agent-anthropic-autoconfigure/src/main/kotlin · high confidence

The system now automatically discovers and registers AI models running locally in Docker containers. On startup, it queries the Docker endpoint (defaulting to http://localhost:12434/engines) to list available models; if the endpoint is unreachable, the application starts cleanly with no models registered rather than failing. Users can customize the connection URL and retry behavior via properties such as embabel.agent.models.docker.base-url and embabel.agent.platform.models.docker.max-attempts.

embabel-agent-autoconfigure/models/embabel-agent-dockermodels-autoconfigure · high confidence

The \embabel-agent-byok-autoconfigure\ module now registers placeholder LLM and embedding services (\setup-required\ and \setup-required-embedding\) that allow a Bring Your Own Key application to boot and resolve model names even when no provider key is configured at startup. This defers the requirement for a key until the first actual call, which must then supply it via \PromptRunner.withLlmService(...)\. The module also ships \CredentialLlmServiceFactory\ and \CredentialEmbeddingServiceFactory\ beans for Anthropic and OpenAI-compatible protocols, enabling the platform to build real services from per-user keys at runtime. To prevent silent data corruption in vector indexes, the embedding placeholder deliberately fails if used before a real model is available, forcing consumers to check for the placeholder and wait.

embabel-agent-autoconfigure/models/embabel-agent-byok-autoconfigure · high confidence

Agent processes can now be persisted to a shared cache, allowing state to survive node restarts and enabling multi-node recovery. This change introduces a cache abstraction (AgentCacheProvider/Region) and a CacheBackedAgentProcessSnapshotStore that stores process snapshots with optimistic concurrency control. A Spring Cache adapter is provided for out-of-the-box support of backends like Caffeine and Redis, while a JCache reference implementation demonstrates atomic compare-and-set for distributed environments. Tests verify that processes checkpointed on one node can be resumed on another and that concurrent updates are correctly rejected.

embabel-agent-cache/embabel-agent-cache-core · high confidence

The models package now provides a comprehensive, type-safe registry of model identifiers for all supported providers, including Anthropic, Atlas Cloud, Alibaba Cloud DashScope, DeepSeek, Docker Local, Google GenAI, LM Studio, MiniMax, Mistral AI, OCI Generative AI, Ollama, OpenAI, and Z.ai. This change introduces dedicated constant classes for each provider to ensure model names are accurate and up to date, while also handling deprecations for retired models (such as Gemini 2.0 and Mistral Large 2.1) by marking them with deprecation annotations and suggesting modern replacements.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/models · high confidence

The Anthropic integration now uses a declarative model registry defined in \anthropic-models.yml\ to manage available models, including the new Claude Opus 4.8, Claude Opus 4.6, Claude Sonnet 4.6, and various 4.x and legacy models, along with their pricing and context details. This registry also configures native structured output support (disabled by default) and is wired into the application via a new Spring Boot auto-configuration class (\AgentAnthropicAutoConfiguration\), simplifying model selection and configuration for users.

embabel-agent-autoconfigure/models/embabel-agent-anthropic-autoconfigure/src/main/resources · high confidence

OpenAI models are now configured declaratively via YAML (openai-models.yml) and auto-registered as Spring beans, allowing users to manage model metadata, pricing, and capabilities centrally. The auto-configuration introduces a dedicated OpenAiResponsesChatModel to route GPT-5.x-pro and other Responses-only models to the /v1/responses endpoint, ensuring compatibility with models that reject Chat Completions requests. Users can now configure OpenAI settings (base URL, API key, completions/embeddings paths) via application properties, and the system supports native structured output configuration for OpenAI models through a dedicated configurer.

embabel-agent-autoconfigure/models/embabel-agent-openai-autoconfigure · high confidence

The system now includes autoconfiguration for DeepSeek AI models. This change introduces a new Spring Boot autoconfiguration entry point that registers beans for various DeepSeek models (such as Chat, Reasoner, V4 Flash, and V4 Pro) using the Spring AI integration. Users can configure the API key and base URL via application properties or environment variables, and the models are automatically available when the DeepSeek dependencies are on the classpath.

embabel-agent-autoconfigure/models/embabel-agent-deepseek-autoconfigure/src/main · high confidence

The new EmbeddingOperations class wraps the underlying embedding service to record token usage and emit detailed events for every embedding call. This enables cost tracking and observability by dispatching events to registered listeners and, when an active agent process is present, recording the invocation details (including token counts and duration) directly on the process for accounting purposes.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/embedding · high confidence

The \embabel-agent-api\ module now includes a new \condition\ package containing the foundational types for condition-based planning (such as GOAP). This change introduces interfaces and data classes for \ConditionAction\, \ConditionGoal\, \ConditionPlan\, and \ConditionWorldState\, along with a \ConditionPlanner\ interface and an \AbstractConditionPlanner\ base class. These components allow planners to operate on world states defined by conditions that can be true, false, or unknown, enabling the reuse of condition logic across different planning algorithms.

embabel-agent-api/src/main/kotlin/com/embabel/plan/common · high confidence

This change introduces the support-layer infrastructure for checkpointing and restoring agent processes, enabling Human-in-the-Loop (HITL) workflows and resilience against runtime failures. It adds a structured snapshot model (\AgentProcessSnapshot\) that captures process state, options, and blackboard contents, along with factories to create these snapshots and restorers to rebuild \SimpleAgentProcess\ and \ConcurrentAgentProcess\ instances from them. A \PersistentAgentProcessRepository\ decorator integrates this by automatically checkpointing processes based on policies (such as \WaitForCheckpointPolicy\ for HITL waits or \LifecycleCheckpointPolicy\ for terminal states) and falling back to durable storage when the in-memory repository misses a lookup. The implementation includes JSON serialization via Jackson, an in-memory snapshot store for testing, and a serializer resolver for blackboard entries, establishing the backend-neutral core required for future cache or database integrations.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/persistence · high confidence

Users can now define global guardrails for user input and assistant messages via the \embabel.agent.guardrails.user-input\ and \embabel.agent.guardrails.assistant-message\ application properties, which accept comma-separated class names. These global guardrails are automatically merged with interaction-specific guardrails during validation, allowing for centralized policy enforcement across all LLM operations. The system also introduces a \fail-on-error\ property to control whether validation failures throw exceptions or are logged as warnings.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/guardrails · high confidence

The Gemini module now automatically registers available Google Gemini models at startup by loading definitions from a YAML file (classpath:models/gemini-models.yml). This configuration-driven approach allows the system to dynamically discover and register models as Spring beans, supporting the latest Gemini 3.5, 3.1, and 2.5 families with their respective pricing and capability metadata. The autoconfiguration integrates with the existing LLM service infrastructure, enabling seamless use of Gemini models through the standard AI agent interfaces while maintaining consistent retry and observation behaviors.

embabel-agent-autoconfigure/models/embabel-agent-gemini-autoconfigure · high confidence

The agent API now includes a validation framework to enforce safety and policy checks on AI interactions. This introduces interfaces for validating user inputs (UserInputGuardRail) before they reach the LLM and assistant responses (AssistantMessageGuardRail) after generation, along with a base GuardRail interface for string-based validation. A configuration class (GuardRailConfiguration) allows users to define which guardrails to apply, and a new TokenBudgetGuardRail implementation is provided to limit input size based on token estimates. This change establishes the structural foundation for content safety and compliance within the agent API.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/validation · high confidence

The agent API now supports pausing execution to request user input before continuing. This introduces an Awaitable mechanism where tools can throw an AwaitableResponseException to halt, allowing the UX to present confirmation dialogs (ConfirmationRequest), typed value inputs (TypeRequest), or structured forms (FormBindingRequest). Developers can use helper functions like confirm() and fromForm() to easily integrate these interactions, and existing tools can be wrapped with decorators like withConfirmation() or requireType() to enforce user approval or data entry before execution.

embabel-agent-api/src/main/kotlin/com/embabel/agent/core/hitl · high confidence

This change introduces the initial structure for the Embabel Agent documentation site. It includes the core Asciidoc source files for the User Guide (covering installation, quickstart, agent design, and guides), a custom JavaScript extension to generate \llms.txt\ for AI indexing, a Python script for document chunking via Docling, and a Graphviz diagram for the planning process. It also adds the necessary build configuration (README, Maven instructions) and static assets (logo, footer/header HTML) to support the documentation build pipeline.

embabel-agent-docs · high confidence

The new embabel-agent-a2a module exposes the agent platform via the A2A protocol, registering Spring MVC endpoints for agent card discovery and JSON-RPC message handling. It supports both synchronous task execution and asynchronous streaming via Server-Sent Events (SSE), including task resubscription and event replay. The server automatically generates an agent card and skills list from the platform's configured goals, and emits platform events for incoming requests and outgoing responses.

embabel-agent-a2a/src/main/kotlin · high confidence

The new \embabel-agent-skills\ module implements the Agent Skills specification, allowing users to load skills from local directories or GitHub repositories. It introduces embedding-driven skill selection, which injects skill instructions into prompts based on semantic similarity rather than requiring the model to explicitly activate them. For script execution, the module provides a \ProcessSkillScriptExecutionEngine\ for direct host execution and containerized engines (\DockerSkillScriptExecutionEngine\ and \PodmanSkillScriptExecutionEngine\) that run scripts in isolated OCI containers with configurable CPU, memory, and network limits. Input files are confined to a user root to prevent path traversal, and artifacts from one skill can be reused by subsequent ones.

embabel-agent-skills · high confidence

The \embabel-agent-byok\ module now provides a generic \ByokFactory\ interface and a \detectProvider\ function that concurrently validates API keys across multiple providers, returning the first successful service. It also includes \validatedEmbeddingService\ to probe and stamp the actual vector width from the model, and \requireUsableApiKey\ to reject blank or absent keys early with a clear error message.

embabel-agent-common/embabel-agent-byok · high confidence

This change adds a new autoconfiguration module for Google GenAI (Gemini) models, enabling the system to automatically discover and register Gemini chat and embedding models from a YAML configuration file. It includes a Spring Boot autoconfiguration entry point, a model loader that parses model definitions (including pricing, token limits, and thinking budget settings), and configuration properties for API key and Vertex AI authentication. The module registers specific Gemini models (such as Gemini 3.5 Flash, 3.1 Pro Preview, and 2.5 Flash) as LLM and embedding services, and includes integration tests to verify model registration and basic functionality.

embabel-agent-autoconfigure/models/embabel-agent-google-genai-autoconfigure · high confidence

This change adds a new autoconfiguration module for Oracle Cloud Infrastructure (OCI) Generative AI, enabling users to connect to OCI-hosted LLMs and embedding models. The implementation is fully compatible with Spring AI 2.0, migrating from the deprecated OciGenAiChatOptions to the standard ToolCallingChatOptions contract and removing the old convertOptions API. The module provides an auto-configuration class that registers the OCI client and model services, an environment post-processor that sets default models (Cohere Command A for chat, Cohere Embed v4.0 for embeddings) when no other provider is present, and a YAML-based model loader for defining available models. It supports multiple authentication types (file, instance principal, resource principal, workload identity, simple, session token) and offers configurable serving modes (on-demand, dedicated) and API formats (Generic, Cohere V2, Cohere).

embabel-agent-autoconfigure/models/embabel-agent-oci-genai-autoconfigure · high confidence

Agents can now route messages and progress updates to external systems via the new OutputChannel interface and its event types (MessageOutputChannelEvent, LoggingOutputChannelEvent, ProgressOutputChannelEvent), with a DevNullOutputChannel for silent operation and MulticastOutputChannel for fan-out. The new Actor class provides a convenient way to combine an LLM, a persona (PromptContributor), and tool groups into a single unit that produces a configured PromptRunner. Additionally, the API adds first-class support for multimodal inputs through MultimodalContent, AgentImage, and AgentDocument, allowing agents to include images and documents in prompts alongside text.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common · high confidence

This change adds the foundational SPI for saving and restoring agent process state, enabling human-in-the-loop (HITL) workflows and resilience against runtime failures. It introduces the \AgentProcessPersistence\ entry point, which assembles a durable \AgentProcessRepository\ by wrapping a fast runtime repository with a configurable snapshot store. The diff defines the \AgentProcessCheckpointPolicy\ interface to control when processes are saved, the \AgentProcessSnapshotStore\ interface for backend-agnostic storage (supporting create-only or compare-and-set semantics), and the \SerializedAgentProcessSnapshot\ data class that envelopes the serialized process payload with concurrency metadata.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/persistence · high confidence

Users can now define AWS Bedrock LLM and embedding models via a YAML configuration file (default: classpath:models/bedrock-models.yml). The new BedrockModelLoader and BedrockModelsConfig components automatically discover, validate, and register these models as Spring beans, supporting region-specific identifiers (including ARNs), per-token pricing, and configurable retry policies for API calls.

embabel-agent-autoconfigure/models/embabel-agent-bedrock-autoconfigure/src/main/kotlin · high confidence

This change adds a new Spring Boot autoconfiguration module that enables the use of OpenAI-compatible APIs (such as Groq or Together AI) by allowing users to register custom model IDs via the \embabel.agent.platform.models.openai.custom.models\ property or the \OPENAI\_CUSTOM\_MODELS\ environment variable. The configuration supports setting a custom base URL, API key, and specific API paths for completions and embeddings, while automatically registering the specified models as beans and reporting them through provider initialization metadata.

embabel-agent-autoconfigure/models/embabel-agent-openai-custom-autoconfigure · high confidence

Added a new persistence foundation for agent process snapshots, introducing the \BlackboardPersistence\ module. This includes an \AgentProcessPersistenceException\ for handling checkpoint and restore failures, and a \BlackboardEntrySerializer\ interface that allows applications to define custom serialization logic for blackboard values. The change also adds supporting data classes (\SerializedBlackboardValue\, \BlackboardEntrySerializationContext\, \BlackboardEntryDeserializationContext\) to manage the durable payload format and context during serialization and deserialization, enabling stateless and concurrent-safe persistence of agent state.

embabel-agent-api/src/main/kotlin/com/embabel/agent/core/persistence · high confidence

The agent API now includes a general-purpose, composable property filter system (\PropertyFilter\) that allows filtering based on key-value maps using operators such as equality, comparison, containment, regex, and logical combinations (AND, OR, NOT). A new \HasElement\ filter enables checking membership of a value within list-valued properties. An in-memory evaluator (\InMemoryPropertyFilter\) is provided to apply these filters against maps, serving as a fallback when native query support is unavailable or for evaluating guard conditions. Additionally, an \ObjectFilter\ interface is introduced as an extension point, allowing external modules to define custom filter types within the hierarchy.

embabel-agent-api/src/main/kotlin/com/embabel/agent/filter · high confidence

This change introduces the foundational core model for the agent system, defining the primary interfaces and classes that drive agent execution. It establishes the \Action\ interface with support for retry policies (\ActionQos\, \ActionRetryPolicy\) and exception classification (\ActionException\), the \Agent\ and \AgentScope\ models for defining capabilities, and the \AgentProcess\ interface for tracking execution state, history, and cost. Additionally, it provides the \AgentPlatform\ for managing and running agents, the \Blackboard\ for maintaining process context, and the \AgentProcessRepository\ with support for ephemeral processes.

embabel-agent-api/src/main/kotlin/com/embabel/agent/core · high confidence

The platform now includes in-memory implementations for agent process and context storage that prevent unbounded memory growth. \InMemoryAgentProcessRepository\ and \InMemoryContextRepository\ enforce a configurable window size, using a \HierarchyAwareEvictionPolicy\ to safely remove only finished process hierarchies and oldest contexts when limits are reached. This ensures that long-running agent sessions and context data remain bounded without requiring external persistence for these specific in-memory use cases.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support · high confidence

The new embabel-agent-shell module provides a terminal-based interface for interacting with the Embabel Agent platform, built on the Spring Shell framework. It introduces a suite of interactive commands for agent management, chat sessions, task execution, and system operations, including listing agents, executing tasks, and managing a persistent blackboard state. The shell supports interactive chat sessions with configurable log redirection to files, form handling for user inputs, and human-in-the-loop goal approval. Users can customize the terminal experience with personality-based prompt providers (such as Star Wars, Hitchhiker's Guide, and Severance themes) and benefit from improved console output formatting that renders Markdown, code blocks, and links with ANSI styling.

embabel-agent-shell · high confidence

The embabel-agent-observability module provides automatic tracing, metrics, and log correlation for AI agents with zero code changes. It integrates with OpenTelemetry-compatible exporters (Langfuse, LangSmith, Zipkin, OTLP) and Prometheus for metrics. Users can configure granular tracing for agent actions, tool loops, LLM calls, and RAG, while controlling message content capture for privacy. The module also propagates agent run context into SLF4J MDC for log correlation across thread boundaries and exposes business metrics like token usage, costs, and agent duration via Micrometer.

embabel-agent-observability · high confidence

This change adds a new provider-neutral streaming architecture to the agent API, introducing the \LlmMessageStreamer\ interface and the \StreamingToolLoop\ SPI. The \LlmMessageStreamer\ allows provider adapters to stream LLM inference events (content chunks and complete messages) without handling tool execution, while the \StreamingToolLoop\ manages the multi-turn conversation loop, tool execution, and iteration logic. This enables Embabel to support streaming capabilities across different LLM providers (like Spring AI or LangChain4j) through a unified, vendor-neutral interface.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/loop/streaming · high confidence

The platform now automatically configures \RestClient\ and \WebClient\ builders backed by Reactor Netty for AI model communication, controlled by the \embabel.agent.platform.http-client.use-reactor-netty\ property (enabled by default). Users can customize connection and read timeouts via \embabel.agent.platform.http-client.connect-timeout\ and \embabel.agent.platform.http-client.read-timeout\, with defaults of 25 seconds and 5 minutes respectively. The Netty client is configured to follow redirects, ensuring robust connectivity to model endpoints.

embabel-agent-autoconfigure/embabel-agent-netty-client-autoconfigure · high confidence

The RAG pipeline now includes a configurable enhancement stage that processes search results before returning them to the user. This stage applies a sequence of improvements—deduplication, adjacent chunk merging, optional LLM-based contextual compression, LLM-based reranking, and final filtering—while supporting adaptive execution to skip expensive steps if quality is already high or latency limits are reached. The pipeline also supports HyDE (Hypothetical Document Embedding) to generate synthetic queries for better initial retrieval, and emits detailed events at each step for observability.

embabel-agent-rag/embabel-agent-rag-pipeline · high confidence

The \embabel-agent-api\ module now includes a new internal SPI for structured observability, providing context classes (\ActionObservationContext\, \AgentObservationContext\, \LlmObservationContext\, \ToolLoopObservationContext\) and a \NoOpAgentInstrumentation\ default. This allows the core agent logic to create spans for actions, agent turns, LLM requests, and tool loops via Micrometer, while ensuring that no spans are created if no observability adapter is present.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/event/observation · high confidence

The chat API now supports multimodal messages, allowing users to include images and documents alongside text in conversations via new \ContentPart\ types (\ImagePart\, \DocumentPart\) and a \UserMessageBuilder\. Additionally, a new asset management system has been added, enabling the tracking of assets within conversations through \AssetTracker\ and \AssetView\. This system supports durable storage of assets via the \AssetStore\ SPI, allowing tools to produce and persist materializable assets that survive beyond the conversation's lifetime.

embabel-agent-api/src/main/kotlin/com/embabel/chat · high confidence

The identity module now exposes a \User\ interface and a \SimpleUser\ data class to standardize user identity properties (id, displayName, username, email) across the system. Additionally, a \UserService\ interface is provided to allow applications to retrieve users by ID, username, or email, and to provision new users, offering a consistent API for identity operations.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/identity · high confidence

The planning module now exposes a foundational domain model for goal-oriented action planning. Users can define plans as ordered chains of actions targeting specific goals, with each action and goal supporting dynamic, state-dependent cost and value computations (ranging from 0 to 1). The system includes a generic Planner interface that supports planning to specific goals or selecting the best plan across multiple goals based on net value. It also introduces mechanisms to prevent infinite loops during replanning by allowing the exclusion of specific actions, and provides a pruning capability to remove irrelevant actions from a planning system to improve efficiency.

embabel-agent-api/src/main/kotlin/com/embabel/plan · high confidence

A new StreamingPromptRunnerBuilder record has been added to the streaming API package, providing a Java-compatible builder pattern that mirrors Kotlin's asStreaming() extension function. This allows Java users to access streaming operations on PromptRunner instances through a type-safe streaming() method, which validates that the underlying LLM supports streaming before returning the appropriate StreamingPromptRunner.Streaming capability.

embabel-agent-api/src/main/java/com/embabel/agent/api/streaming · high confidence

A new Java utility class, WaitFor, has been added to the core HITL package to provide static convenience methods for human-in-the-loop interactions. This class exposes form submission, confirmation, and awaitable wait operations by delegating to the underlying Kotlin WaitKt functions, allowing Java users to interact with these features using standard Java syntax.

embabel-agent-api/src/main/java/com/embabel/agent/core · high confidence

The LM Studio integration now automatically discovers models from a local LM Studio instance at startup and registers them as beans. The configuration normalizes the base URL to ensure completions are sent to the /v1 endpoint while discovery queries the raw address, and it distinguishes between LLM and embedding models based on the type reported by the server. This allows locally served models to be usable immediately upon appearance without requiring a restart, and includes tests to verify graceful handling when the endpoint is unavailable.

embabel-agent-autoconfigure/models/embabel-agent-lmstudio-autoconfigure · high confidence

The embabel-agent-onnx module now provides a local embedding service using ONNX Runtime, defaulting to the all-MiniLM-L6-v2 model (384 dimensions). It includes an OnnxModelLoader utility that automatically downloads and caches ONNX model files from HTTPS sources (such as Hugging Face) or uses local file URIs, ensuring models are reused across runs. The OnnxEmbeddingService implements the standard EmbeddingService interface, allowing users to generate embeddings locally without external API calls, with pricing set to null since inference is local.

embabel-agent-onnx · high confidence

The Lucene search implementation has been upgraded to support vector embeddings with up to 4096 dimensions (via a custom HighDimensionVectorCodec), enabling compatibility with larger embedding models like OpenAI's 1536-dimension vectors. Additionally, the search operations now persist and retrieve the full content element hierarchy—including Documents, Sections, and Chunks—rather than just text chunks, allowing for more structured retrieval and accurate persistence of document metadata and structure across restarts.

embabel-agent-rag/embabel-agent-rag-lucene · high confidence

The MCP server now exposes its operational status through the standard Spring Boot Actuator health endpoint. When Spring Boot Actuator is on the classpath, the system automatically registers a health indicator that reports the server's state (up, down, or out of service) based on its initialization progress and health evaluation. This allows users to monitor the server's readiness and diagnose issues via the /actuator/health endpoint, with detailed information including execution mode, tool count, and initialization state. The feature can be disabled via the embabel.agent.mcpserver.health.enabled property.

embabel-agent-autoconfigure/embabel-agent-mcpserver-autoconfigure · high confidence

The platform now supports MiniMax AI models (M3, M2.7, and M2.7-Highspeed) out of the box. When the MiniMax dependencies are on the classpath and the MINIMAX\_API\_KEY environment variable is set, the system automatically registers these models as LLM services. The configuration allows for custom base URLs and API keys via the embabel.agent.platform.models.minimax prefix, and includes built-in retry logic and temperature clamping (0.01 to 1.0) to ensure compatibility with MiniMax's API requirements.

embabel-agent-autoconfigure/models/embabel-agent-minimax-autoconfigure · high confidence

The Mistral AI provider is now available for use with the Embabel Agent system. This change introduces auto-configuration that loads a curated list of Mistral models (including Medium, Small, Ministral, Magistral, and Codestral variants) from a bundled YAML catalog, registering them as beans with their specific capabilities, pricing, and token limits. The configuration supports setting the API key and base URL via environment variables or application properties, and integrates with the platform's shared HTTP client and retry policies to ensure reliable communication with the Mistral API.

embabel-agent-autoconfigure/models/embabel-agent-mistral-ai-autoconfigure · high confidence

The A2A (Agent-to-Agent) auto-configuration module now automatically registers the Agent card endpoint (/{path}/.well-known/agent.json) and the JSON-RPC endpoint (/{path}) when running in a servlet web application with A2A classes on the classpath. This enables seamless integration of agent communication protocols without manual setup.

embabel-agent-autoconfigure/embabel-agent-a2a-autoconfigure · high confidence

A new AgentScopeBuilder interface has been introduced to provide a standardized way of creating AgentScope instances. This interface includes static factory methods, fromInstance and fromInstances, which allow users to build agent scopes from single or multiple annotated components. The fromInstances method specifically supports combining actions, goals, and conditions from multiple sources into a single scope, while also handling the aggregation of stuck handlers.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/scope · high confidence

The \embabel-agent-api\ module introduces a new \AgenticTool\ interface and subpackages (\playbook\, \simple\, \state\) to enable LLM-driven tool orchestration. Users can now create \SimpleAgenticTool\ instances where all sub-tools are available immediately, or \PlaybookTool\ instances that progressively unlock sub-tools based on conditions such as prerequisite tool calls, produced artifacts, or blackboard state. A \StateMachineTool\ variant is also provided for state-based availability. The API includes fluent configuration methods (e.g., \withLlm\, \withSystemPrompt\, \withMaxIterations\) and supports automatic binding of domain object tools via \DomainToolSource\ and \DomainToolTracker\, allowing \@LlmTool\ methods on domain instances to be exposed as tools during execution. Support utilities like \AgenticToolSupport\ and \ArtifactCollector\ facilitate execution and artifact handling.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/agentic · high confidence

Agents running on macOS can now execute arbitrary AppleScript commands via a new \AppleScriptTools\ service. This tool, available under the 'AppleScript' group, allows users to run scripts and receive the execution exit code, facilitating OS-level automation tasks directly from the agent.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/osx · high confidence

Added a new set of tools (\BlackboardTools\) that allow agents to interact with the current process's blackboard. This includes capabilities to list all objects, retrieve objects by binding name, fetch the most recent object of a specific type, describe objects, and count objects by type. The tools are implemented as an \UnfoldingTool\ and support custom formatting via \BlackboardEntryFormatter\.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/blackboard · high confidence

A new ConsensusBuilder class has been added to the multimodel workflow package, enabling users to construct workflows that aggregate results from multiple generators using a specified consensus function. This builder leverages the existing ScatterGather mechanism to handle concurrency and joins the outputs, providing a structured way to implement consensus-based logic in multi-model scenarios.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/workflow/multimodel · high confidence

The agent API now provides a dedicated Kotlin DSL (in \AgentBuilder\, \TypedAgentScopeBuilder\, and \agent.kt\) for constructing agents and their behavior. Users can define agents with specific names, versions, and descriptions, and register actions, goals, and conditions. The DSL supports creating non-LLM transformations (\transformation\) and LLM-based prompt transformers (\promptedTransformer\), including dynamic cost and value computations. It also introduces flow composition capabilities, allowing users to chain actions (\andThen\, \chain\), split data (\split\), and branch logic (\branch\) using typed scopes. Additionally, parallel execution of transformations is supported via \parallelMap\ and \mapAsync\ in \mapper.kt\, enabling concurrent processing with configurable concurrency levels.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/dsl · high confidence

The API now includes several new LlmReference implementations to expose different data sources to the agent: EagerSearch for preloading vector/keyword similarity results, LiteralText for in-memory notes, LocalDirectoryReference for readonly filesystem access, SpringResource for loading file contents into memory, and WebPage for referencing external URLs. Additionally, the LlmReference interface now supports an withUnfolding() method to wrap references in a single progressive tool, and LlmReferenceProviders allows loading these references from YAML configuration files.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/reference · high confidence

A new MathTools class has been added to the agent API, providing a suite of mathematical operations (add, subtract, multiply, divide, mean, min, max, floor, ceiling, round) accessible to language models. These operations are exposed as an UnfoldingTool, allowing the LLM to discover and invoke specific functions dynamically. The class implements ToolGroup and AssetCoordinates, supporting both direct usage via the UnfoldingTool facade and registration as a tool group for automatic resolution within the platform.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/math · high confidence

The ONNX embedding service is now automatically configured when ONNX Runtime dependencies are present. The system downloads the default model (all-MiniLM-L6-v2) and tokenizer from HuggingFace on first use, caching them locally. Users can control this behavior via the \embabel.agent.platform.models.onnx.embeddings.enabled\ property (defaulting to true) and customize the model URI, tokenizer URI, cache directory, vector dimensions, and model name through standard Spring Boot configuration properties.

embabel-agent-autoconfigure/models/embabel-agent-onnx-autoconfigure · high confidence

A new PromptCondition class has been added to the agent API, allowing conditions to be evaluated by prompting an LLM rather than using static logic. This enables more flexible, context-aware decision-making in planning systems, where the condition's truth value is determined by sending a prompt to an LLM and parsing the result (true/false, confidence, explanation).

embabel-agent-api/src/main/kotlin/com/embabel/agent/experimental/primitive · high confidence

The RAG core module now includes a structured ingestion pipeline with new interfaces and implementations for fetching content (HTTP, RSS), parsing hierarchical documents, and chunking text with configurable transformers. Additionally, a new filtering system has been added, introducing \EntityFilter\ for label-based entity matching and \InMemoryPropertyFilter\ for in-memory result filtering, allowing searches to be constrained by metadata and entity labels.

embabel-agent-rag/embabel-agent-rag-core · high confidence

This update introduces a new set of REST endpoints in the webmvc module to expose agent platform state and control. Users can now query the status of agent processes (including current status, running time, and last result) via GET /api/v1/process/{processId}, terminate running processes via DELETE /api/v1/process/{id}, and subscribe to real-time process events via Server-Sent Events (SSE) at /events/process/{processId}. Additionally, a new /api/v1/platform-info endpoint provides a summary of the platform, including lists of agents, goals, actions, conditions, models, and tool groups. These endpoints are enabled by default but can be individually disabled via feature toggles (embabel.agent.platform.rest.process-status-enabled, process-kill-enabled, process-events-enabled). A global exception handler has also been added to standardize 404 responses for missing endpoints.

embabel-agent-common/embabel-agent-webmvc · high confidence

The agent SPI module introduces a set of new interfaces that allow platform providers to customize core agent behaviors and support Bring Your Own Key (BYOK) scenarios. Key additions include LlmService for framework-agnostic LLM abstraction, PlannerFactory for pluggable planning strategies, and OperationScheduler for controlling action timing. To support BYOK, PlaceholderLlmService and PlaceholderEmbeddingService act as markers for models without configured keys, enabling applications to start without fatal errors while keys are pending. Additional SPIs like BlackboardProvider, ContextRepository, AutoLlmSelectionCriteriaResolver, ToolDecorator, ToolGroupResolver, and AgentProcessIdGenerator provide hooks for customizing context management, LLM selection, tool execution, and process ID generation.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi · high confidence

The workflow control API now includes a ScatterGather pattern for generating multiple results in parallel and consolidating them, along with a SimpleAgent builder for creating agents that perform a single operation. These new DSL components allow users to define parallel generation workflows with configurable concurrency and simple single-action agents more easily.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/workflow/control · high confidence

Added \InjectionUtils\ and \Injector\ components in the \embabel-agent-api\ module to enable cascading dependency injection for Spring beans. The \InjectionUtils.wire\ method allows objects implementing the new \Injectable\ interface to specify additional dependencies that are automatically injected, while the \Injector\ component provides a convenient way to trigger Spring injection on objects annotated with \@Configurable\.

embabel-agent-api/src/main/kotlin/com/embabel/agent/experimental/util · high confidence

A new StringTransformer interface has been introduced in the common utilities package, allowing users to define and chain multiple string transformation functions. This utility provides a convenient way to apply a sequence of transformations to raw string input, with built-in support for identity transformation and composition of multiple transformers into a single operation.

embabel-agent-api/src/main/kotlin/com/embabel/common/util · high confidence

A new WorkflowBuilder class and associated interfaces (WorkflowBuilderReturning, WorkflowBuilderConsuming) have been introduced to standardize how workflows are defined and agents are constructed. This change provides a consistent naming convention for specifying input and result types, and adds convenience methods like buildAgent() for registering agents and asSubProcess() for embedding workflows within other actions, ensuring that input preconditions are correctly validated when used as sub-processes.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/workflow · high confidence

The \embabel-agent-api\ introduces a new \invocation\ package that provides a structured way to invoke agents. This includes \AgentInvocation\ for general platform-based invocations, \UtilityInvocation\ for running agents with all available platform actions (including a new \terminateWhenStuck\ policy), and \SupervisorInvocation\ which uses an LLM to orchestrate tool actions toward a specific goal type. The API also adds \ScopedInvocation\ for defining action scopes and custom agent names, and \TypedInvocation\ for returning specific result types.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/invocation · high confidence

A new \AgentProcessTools\ component has been added to the agent API, exposing an \UnfoldingTool\ named \agent\_process\ that allows agents to inspect their own runtime state. This includes sub-tools for checking process status (ID, state, running time), budget limits and remaining capacity (cost, tokens, actions), detailed cost and token usage statistics, action history, and tool usage metrics. These tools enable agents to self-monitor their execution context and resource consumption.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/process · high confidence

This change introduces a new set of components in the agent tools package to support creating and managing tools from Embabel agents. It adds \AgentTool\ and \GoalTool\ implementations that wrap agent execution as callable tools, along with \PerGoalToolFactory\ and \AchievableGoalsToolGroupFactory\ to dynamically generate tool groups based on available goals and the current operation context. The update also includes \DefaultProcessCallbackTools\ for handling human-in-the-loop interactions like form submissions and confirmations, \TextCommunicator\ and \PromptedTextCommunicator\ for formatting responses, and \GoalToolNamingStrategy\ for consistent tool naming. Additionally, \TypeWrappingToolDefinition\ is added to generate JSON schemas for tool inputs.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/agent · high confidence

The validation module now includes a comprehensive set of validators that enforce agent structure and goal achievability. The DefaultAgentStructureValidator ensures agents have at least one goal, detects empty agents, and validates that action and condition method signatures are correct (e.g., conditions must have at most one parameter). The AchievableGoalValidator verifies that methods annotated with @AchievesGoal also have the @Action annotation. The GoapPathToCompletionValidator uses the GOAP planner to check if there is a valid path from initial conditions to goals, reporting errors if no starting action exists or if goals are unreachable. Additionally, the DefaultValidationPromptGenerator provides utilities to generate validation requirement prompts and violation reports for JSR-380 annotated types, supporting better feedback for LLM-driven validation scenarios.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/validation · high confidence

This update introduces a new set of tool interfaces and implementations in the \embabel-agent-api\ module to support advanced agentic workflows. Key additions include \AgenticTool\ for LLM-driven orchestration of sub-tools, \ArtifactSinkingTool\ and \ArtifactSinkFactory\ for capturing and routing tool artifacts to sinks like the blackboard, and \OneShotPerLoopTool\ with \LoopMemo\ to enforce single-execution-per-loop semantics for tools like skill activators. The \MethodTool\ implementation now supports \@LlmTool\ annotations on both Kotlin and Java methods, with improved handling of CGLIB-proxied beans and \ToolCallContext\ injection. Additionally, new built-in tools \CommunicateTool\ and \ProgressTool\ allow agents to send persistent messages and transient status updates to users via the output channel.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool · high confidence

The annotation package introduces a new model for defining agent capabilities: @LlmTool marks methods as LLM-invocable tools with support for categories and metadata; @UnfoldingTools enables progressive tool disclosure by grouping tools behind a facade; @RunSubagent provides a mechanism to nest and execute subagents from action methods; @Provided allows injecting platform services directly into action parameters; and @Cost enables dynamic cost evaluation for planning. These annotations replace older patterns and are processed by the agent metadata reader to configure tool definitions and action behaviors.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/annotation · high confidence

The API now includes the \@AchievesGoal\ annotation, allowing developers to mark methods as achieving specific goals with configurable descriptions, values, tags, and example scenarios. It also introduces the \@Export\ annotation to control how these goals are exposed, supporting settings for remote/local visibility, custom names, and starting input types. These changes provide a structured way to define agent capabilities and manage their export behavior.

embabel-agent-api/src/main/java/com/embabel/agent/api/annotation · high confidence

The MCP server security auto-configuration module now automatically secures MCP endpoints (\/sse/\, \/mcp/\, \/message/\) using a stateless OAuth2 resource server that validates JWT bearer tokens. It extracts granted authorities directly from the JWT's \authorities\ claim without applying any prefix. Additionally, it enables method-level security for agent tools via a \SecureAgentToolAspect\, allowing developers to protect specific tool methods using the \@SecureAgentTool\ annotation with SpEL expressions (e.g., \hasAuthority('tools:use')\). This ensures that only authenticated users with the correct permissions can invoke protected agent actions.

embabel-agent-autoconfigure/embabel-agent-mcpserver-security-autoconfigure · high confidence

This change introduces the core implementation for the chatbot system within the agent API. It adds AgentProcessChatbot, which manages chat sessions backed by an AgentProcess, supporting features like conversation persistence, budget control, and configurable verbosity. A new DefaultChatAgentBuilder simplifies creating chat agents with a standard prompt template and blackboard formatting. Additionally, a default persona named 'Marvin' (based on the Hitchhiker's Guide character) is provided out-of-the-box for immediate use.

embabel-agent-api/src/main/kotlin/com/embabel/chat/agent · high confidence

The chat support package now includes several new capabilities. EventPublishingConversation and the associated MessageEvent/MessageStatus types allow applications to subscribe to message lifecycle events (added, persisted, persistence failed) for any conversation implementation. Asset management is supported via AssetTracker (with an InMemoryAssetTracker implementation), AssetAddingTool (which automatically converts tool artifacts into assets), and FileSystemAssetStore (which provides durable, SHA-256 hashed storage for assets). Additionally, InMemoryConversation now supports an asset tracker and a last(n) method to retrieve recent messages, while TokenBudgetConversationFormatter enables formatting conversations by selecting only the most recent messages that fit within a specified token budget.

embabel-agent-api/src/main/kotlin/com/embabel/chat/support · high confidence

The embabel-agent-code module introduces a suite of tools for interacting with software projects. Agents can now build and test code via CI tools (supporting Maven and interactive modes), perform Git operations (clone, branch, commit, revert), and search codebases for classes or patterns. Additionally, an API reference system extracts class and method signatures from source or classpath, allowing agents to look up signatures by name or package.

embabel-agent-code · high confidence

Added ChatConsole and ConsoleOutputChannel to enable interactive, text-based chat sessions directly in the terminal. ChatConsole provides a simple loop for sending user messages and receiving responses, while ConsoleOutputChannel formats and displays agent events (messages, content, progress, and logs) with optional color highlighting.

embabel-agent-api/src/main/kotlin/com/embabel/chat/support/console · high confidence

The embabel-agent-domain module introduces a new library of domain models for structured content and research. This includes a Blog model with title, author, and markdown format support; a NewsStory model for tracking relevant news with URL and summary; a ResearchTopic and ResearchReport model for managing research queries and reports with links; a Person interface with Jackson deserialization support; and a generic Summary model. These classes implement common interfaces like ContentAsset and PromptContributor to facilitate integration with AI prompts and serialization.

embabel-agent-domain · high confidence

The agent API now introduces dedicated domain types to structure conversation data: \UserInput\ represents a single user message and implements the new \UserContent\ interface, while \SystemOutput\ and its \FileArtifact\ implementation handle system-side outputs. All these types (\UserInput\, \UserContent\, \AssistantContent\, \SystemOutput\, \FileArtifact\) now extend \Timestamped\, ensuring that every input and output carries a creation timestamp for tracking and guardrail purposes.

embabel-agent-api/src/main/kotlin/com/embabel/agent/domain/io · high confidence

The agent platform now emits structured events for key operational moments, enabling observability, billing, and custom monitoring. Platform-level events (e.g., AgentDeploymentEvent, DynamicAgentCreationEvent) are available via AgenticEventListener.onPlatformEvent. Process-level events (e.g., StateTransitionEvent, GoalAchievedEvent, ToolLoopStart/CompletedEvent, ActionExecutionStart/ResultEvent) are available via AgenticEventListener.onProcessEvent. Per-call LLM and Embedding usage events (LlmInvocationEvent, EmbeddingInvocationEvent) expose model, usage, and cost details for each individual call, supporting per-call cost tracking and observability. Embedding events are also exposed independently of any agent process via EmbeddingEventListener so standalone callers can subscribe. Ranking decisions emit RankingChoiceRequestEvent, RankingChoiceMadeEvent, and RankingChoiceCouldNotBeMadeEvent, including confidence cutoffs and basis information. Listeners are multicast and isolated so that listener exceptions do not disrupt agent execution.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/event · high confidence

The \embabel-agent-api\ module now includes a new set of file tools (\FileReadTools\, \FileWriteTools\, \FileTools\) that allow agents to read, write, and modify files on the host machine. These tools introduce a \FileChangeLog\ to track modifications (create, edit, delete, append) and a \FileReadLog\ to monitor file access, providing better visibility into agent actions. The implementation includes a \DefaultFileChangeLog\ that handles duplicate change records and a \LocalDirectory\ reference for accessing local project directories. Additionally, \WellKnownFileContentTransformers\ are provided to sanitize file content (e.g., removing license headers, comments, and whitespace) before processing, which helps reduce token usage and improve LLM performance. The tools also support glob-based file searching and pattern matching within projects.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/file · high confidence

The \embabel-agent-api\ module now includes a complete form processing pipeline under \com.embabel.ux.form\. This introduces a representation-independent form definition (\Form\, \Control\) that can be automatically generated from JVM data classes via \SimpleFormGenerator\, which maps Kotlin/Java properties to UI controls (text fields, checkboxes, date pickers, etc.) and skips auto-populated optional parameters. Submitted form data is processed by \DefaultFormProcessor\, which validates inputs against built-in validators (required, pattern, range, dropdown options) and produces a \FormSubmissionResult\. Finally, \FormBinder\ (with \KotlinFormBinder\ and \JavaFormBinder\ implementations) binds validated submission values back to target data classes, supporting both Kotlin reflection-based binding and Java record/constructor binding, including accessible constructor invocation for Java records.

embabel-agent-api/src/main/kotlin/com/embabel/ux · high confidence

A new Spring Boot starter, embabel-agent-starter-shell, has been added to enable interactive command-line functionality for Embabel Agent applications. This starter provides auto-configuration for a full-featured shell interface, allowing users to list and execute agents, manage goals and tools, view blackboard state, and engage in chat sessions. It includes configurable logging personalities (such as Star Wars or Hitchhiker's Guide themes), command history, and human-in-the-loop confirmation prompts, all accessible via a set of predefined shell commands like \execute\, \chat\, and \agents\.

embabel-agent-starters · high confidence

The \embabel-agent-test-internal\ module now provides a dedicated test application context (\AgentTestApplication\) that explicitly scans the agent framework's core packages, along with a suite of reusable DSL agent builders (such as \splitGarden\ and \EvilWizardAgent\) and domain data fixtures (like \Frog\ and \MagicVictim\) to simplify integration testing. It also includes a \StubChatServer\ for simulating HTTP chat responses, a \FakeAiConfiguration\ that registers mock LLM and embedding services to allow tests to run without real API keys, and specific test support for verifying the tool loop's re-prompt behavior after blank turns.

embabel-agent-test-support/embabel-agent-test-internal · high confidence

This change introduces the \embabel-agent-observability-autoconfigure\ module, which automatically configures OpenTelemetry and Micrometer tracing for Embabel agents. It registers context-propagation accessors to ensure MDC correlation keys and live spans cross thread boundaries during async execution, preventing orphaned traces. The module also provides an HTTP body-caching filter and observation filter to enrich HTTP server observations with request/response details (headers, params, bodies) when \embabel.agent.platform.observability.trace-http-details\ is enabled. Additionally, it configures the core's \AgentInstrumentation\ adapter, registers span conventions for agent/action/tool-loop/LLM events, and applies a tier filter to control which observations are exported based on granular properties like \trace-agent-events\ and \trace-tool-calls\. The module also supports \@Tracked\ annotation-based operation tracking via AspectJ when enabled.

embabel-agent-autoconfigure/embabel-agent-observability-autoconfigure/src/main · high confidence

The \embabel-agent-api\ now includes new classes for structuring LLM prompts: \CoStar\ implements the CO-STAR framework for detailed context, objective, style, tone, audience, and response format; \Instruction\ provides a simple single-instruction persona; \Persona\ (via \PersonaSpec\) structures prompts around a name, persona description, voice, and objective; and \RoleGoalBackstory\ (via \RoleGoalBackstorySpec\) offers a CrewAI-style role/goal/backstory structure with a fluent builder API. All new classes implement \PromptContributor\ to integrate with the existing prompt system.

embabel-agent-api/src/main/kotlin/com/embabel/agent/prompt/persona · high confidence

The tool system now introduces a new type hierarchy to support progressive disclosure of capabilities. A new \NestedTool\ interface allows tools to expose a fixed set of inner tools without requiring an active agent process, enabling out-of-process consumers like REST gateways and documentation generators to inspect tool structures. Building on this, \ProgressiveTool\ extends \NestedTool\ to support context-dependent tool revelation based on the current agent process state. The \UnfoldingTool\ interface provides a concrete implementation for tools that reveal a fixed set of inner tools upon invocation, including support for \childToolUsageNotes\ to provide detailed guidance only when the tool is actually used, and an \exclusive\ mode to replace the entire tool set with inner tools. This structure replaces the previous \MatryoshkaTool\ approach, offering a cleaner separation between static tool grouping and dynamic, context-aware tool discovery.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/progressive · high confidence

Added ToolCallControl and FocusedToolCallControl classes to the prompt element library, allowing users to inject system instructions that limit the number of tool calls an agent can make. ToolCallControl sets a general cap on total tool usage, while FocusedToolCallControl restricts calls to a specific named tool, helping prevent excessive or unbounded tool execution during task completion.

embabel-agent-api/src/main/kotlin/com/embabel/agent/prompt/element · high confidence

A new \promptTransformer\ function has been added to the \embabel-agent-api\ DSL support package, allowing users to define \TransformationAction\ instances that invoke an LLM with a dynamic prompt string. This function accepts configuration for LLM options, tool groups, and a collection of \Tool\ objects, which are passed to the underlying \promptRunner\ to enable tool calling during execution. The function is marked as \@ApiStatus.Internal\, indicating it is intended for use within the agent builder DSL rather than direct user code.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/dsl/support · high confidence

The API module now exposes a new \Ranker\ interface for ranking items based on user input and agent metadata, along with supporting \Rankings\ and \Ranking\ data classes. Additionally, it introduces \LogicalExpression\ and \LogicalExpressionParser\ interfaces to enable parsing and evaluating logical expressions using three-valued logic (TRUE, FALSE, UNKNOWN) against a blackboard state.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/ranking, embabel-agent-api/src/main/kotlin/com/embabel/agent/core/expression · high confidence

This change introduces the \embabel-agent-shell-autoconfigure\ module, which enables the application to run as an interactive command-line shell. It registers an \AgentShellAutoConfiguration\ that scans for shell components, a \ShellEnvironmentPostProcessor\ that applies shell-specific settings (such as disabling the web server and configuring command history) early in the startup process, and \AgentShellProperties\ to allow users to customize shell behavior via the \embabel.agent.shell\ prefix. The module also includes unit tests verifying the auto-configuration and property binding.

embabel-agent-autoconfigure/embabel-agent-shell-autoconfigure · high confidence

Users can now switch the visual style and tone of agent process logs by setting the \embabel.agent.logging.personality\ property to one of four new themes: \colossus\ (a menacing, superior AI tone), \hitchhiker\ (humorous, sci-fi themed messages), \montypython\ (comedy sketches and absurdity), or \severance\ (corporate dystopian jargon). Each personality provides a distinct color palette and customized messages for events such as agent deployment, plan formulation, tool calls, and state transitions, activated via Spring Boot's \@ConditionalOnProperty\ mechanism.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/logging/personality · high confidence

This location introduces the core types for the new thinking capability: a marker interface (ThinkingCapability) to identify prompt runners that support thinking extraction, a specialized exception (ThinkingException) that preserves reasoning blocks even on failure, and a response wrapper (ThinkingResponse) that exposes both the final structured result and the extracted thinking blocks for analysis.

embabel-agent-api/src/main/kotlin/com/embabel/common/core/thinking · high confidence

The agent planning system now includes two new planner implementations in the utility package: \UtilityPlanner\ and \HybridUtilityPlanner\. \UtilityPlanner\ enables value-based action selection, allowing agents to prioritize actions by their net utility score rather than just cost or reachability, and supports a special 'Nirvana' mode for continuous opportunistic behavior. \HybridUtilityPlanner\ combines this value-based selection with goal-satisfaction termination, allowing agents to perform research or enrichment actions (via the Nirvana goal) while ensuring clean shutdown once a primary business goal is achieved. These changes provide more flexible scheduling for agents that need to balance immediate goal completion with long-term value gathering.

embabel-agent-api/src/main/kotlin/com/embabel/plan/utility · high confidence

The \embabel-agent-api\ now includes new classes in the \workflow.loop\ package to support iterative agent workflows. \RepeatUntil\ allows a task to be repeated until a custom boolean acceptance criteria is met, while \RepeatUntilAcceptable\ implements an Evaluator-Optimizer pattern where a task is repeated until a feedback score (via the new \Feedback\ interface and \TextFeedback\ implementation) meets a configurable threshold. Java-friendly builders (\RepeatUntilBuilder\ and \RepeatUntilAcceptableBuilder\) are provided to construct these workflows declaratively.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/workflow/loop · high confidence

The Ollama autoconfiguration module has been restructured to support connecting to multiple Ollama instances simultaneously. Users can now configure additional nodes via the \embabel.agent.platform.models.ollama.nodes\ property list, allowing the system to discover and register models from different servers (e.g., a local instance and a remote GPU server) in a single application context. The configuration logic automatically detects whether to use a default URL, explicit multi-node definitions, or a hybrid of both, and registers the discovered models with node-prefixed bean names to distinguish between identical model names across different servers.

embabel-agent-autoconfigure/models/embabel-agent-ollama-autoconfigure · high confidence

A new TemplatedPromptRunnerBuilder has been added to the agent API, allowing users to dynamically render system prompts using the platform's template renderer. This builder wraps an existing PromptRunner and provides a withSystemPromptTemplate method that loads a named template, renders it with provided model data, and applies the result as the system prompt, keeping template logic separate from the core runner interfaces.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/template · high confidence

The A\* GOAP planner now detects when a goal is unreachable before attempting the full search. If the goal conditions cannot be satisfied by any available actions, the planner logs an error message listing the unsatisfied conditions and returns null, rather than potentially failing silently or wasting resources on an exhaustive search.

embabel-agent-api/src/main/kotlin/com/embabel/plan/goap/astar · high confidence

The agent API's configuration has been reorganized into two new files: \agent-application.properties\ and \agent-platform.properties\. The application file now handles user-facing settings such as the application name prefix, LLM base URLs, and default model selections, while platform-specific internal behaviors (threading, scanning, ranking, autonomy, and REST endpoint toggles) have been consolidated into the platform file. Many properties previously defined in the old \embabel-agent.properties\ have been migrated to use the unified \embabel.agent.platform.\*\ prefix in the new platform file. Additionally, a new \logback-embabel.xml\ has been introduced to standardize logging patterns and levels, resolving previous conflicts with user-supplied logback configurations.

embabel-agent-api/src/main/resources · high confidence

The Anthropic integration has been refactored to support Spring AI 2.0, introducing a new \AnthropicModelFactory\ that enables Bring Your Own Key (BYOK) usage without requiring a Spring context. This migration also adds support for Anthropic prompt caching, allowing users to configure caching for system prompts, tools, and conversation history via \LlmOptions\, and fixes a model-binding issue where the configured model was not being correctly applied to requests.

embabel-agent-anthropic · high confidence

The autonomy package has been restructured to allow the agent platform to accept arbitrary input bindings rather than being limited to UserInput. This is enabled by the new BindingsFormatter interface and its DefaultBindingsFormatter, which convert binding values into strings for goal ranking and intent display. The Autonomy service now exposes a GoalChoiceApprover mechanism, allowing users to veto or approve goal selections based on custom logic or confidence scores. Additionally, the module introduces a PlanLister interface and DefaultPlanLister implementation to list achievable plans from the current world state, and renames DynamicExecutionResult to AgentProcessExecution to better reflect its role in representing the outcome of goal execution.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/autonomy · high confidence

The platform now supports configurable auto-scanning for agents defined as Spring beans. A new \AgentScanningProperties\ class exposes the \embabel.agent.platform.scanning\ configuration prefix, allowing users to control whether agents annotated with \@Agent\ or \@Agentic\ are automatically registered (default: enabled) and whether agents defined as Spring beans are deployed (default: disabled). The \AgentDeployer\ service now respects the \bean\ property to conditionally scan and deploy agent beans, providing clearer logging and control over the deployment process.

embabel-agent-api/src/main/kotlin/com/embabel/agent/core/deployment · high confidence

Users can now configure the tool loop execution strategy via the \embabel.agent.platform.toolloop\ properties, including switching between sequential (default) and parallel execution modes with specific timeouts. Additionally, a new \emptyResponse\ configuration allows setting a retry policy with a custom nudge message when an LLM returns blank text, offering an alternative to the previous behavior of immediately exiting with an empty response exception.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/config · high confidence

The agent API now includes a provider-neutral policy to determine when native structured output can be safely used. This new support layer validates incoming JSON schemas against a conservative compatibility check, ensuring that only schemas fitting a specific safe shape (e.g., objects with compatible properties, nullable unions) are passed to the provider's native output path. If a schema is incompatible in DEFAULT mode, the system falls back to prompt-based extraction and logs a debug message, while ENABLED mode bypasses this check. This change centralizes the decision logic for native structured output support, separating it from provider-specific payload rules.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/nativeoutput · high confidence

The core support package has been significantly restructured to improve encapsulation, thread safety, and observability. AbstractAction now explicitly manages rerun conditions, blackboard clearing, and cost/value computations, while AbstractAgentProcess centralizes history, LLM/Embedding invocation tracking, and cascading termination signals to child processes. A new ConcurrentAgentProcess enables parallel action execution with replan request handling, and InMemoryBlackboard is now thread-safe with support for hiding entries and protected keys. DefaultAgentPlatform wiring has been updated to use the new LlmOperations interface and support concurrent process types, and ActionQosExtensions allow platform-level QoS defaults to be applied to actions without explicit configuration.

embabel-agent-api/src/main/kotlin/com/embabel/agent/core/support · high confidence

The system now uses externalized Jinja templates for core LLM interactions, replacing inline or hardcoded prompt logic. A new default chat template guides the agent to continue conversations and invoke tools based on user intent and context, while a separate template enforces strict JSON structure validation for prompt contributions, requiring certainty before returning success or failure states.

embabel-agent-api/src/main/resources/prompts · high confidence

The AI module now handles malformed LLM JSON responses more robustly by introducing a targeted repair mechanism for incorrectly escaped quotes that previously caused parsing failures, while also enabling lenient parsing features like unescaped control characters. Additionally, a new StreamingJacksonOutputConverter allows structured outputs to be streamed in JSONL format, supporting mixed content streams that include reasoning (thinking) blocks alongside structured data objects, and a new FilteringJacksonOutputConverter enables property-level filtering of generated output schemas.

embabel-agent-common/embabel-agent-ai · high confidence

The internal LLM operation interfaces have been restructured to separate synchronous and streaming concerns. A new \LlmOperations\ interface now centralizes synchronous LLM calls, including methods for generating text, creating output objects, and handling thinking blocks (e.g., \createObjectWithThinking\). A new \StreamingLlmOperations\ interface and its factory (\StreamingLlmOperationsFactory\) have been introduced to handle reactive streaming responses via Project Reactor \Flux\, supporting real-time text chunks, JSONL object streams, and mixed content with thinking events. This change moves LLM operation logic into the \core.internal\ package and provides a cleaner separation for implementations that support streaming capabilities.

embabel-agent-api/src/main/kotlin/com/embabel/agent/core/internal · high confidence

The tool loop now supports configurable strategies for handling two common failure modes: when the LLM returns a blank response with no tool calls, and when it requests a tool that does not exist. For empty responses, the new \EmptyResponsePolicy\ interface allows the loop to either exit immediately (the default, preserving backward compatibility), throw a typed exception, or retry by feeding a synthetic nudge message back to the model. For missing tools, the \ToolNotFoundPolicy\ interface enables automatic self-correction via fuzzy matching (suggesting similar tool names) or immediate failure, with configurable retry limits. These policies are integrated into the \ToolLoopFactory\ and passed to the loop implementations, allowing users to tune resilience against weak model behaviors without changing core loop logic.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/loop · high confidence

This change refactors the agent API's execution layer by introducing the \PromptExecutionDelegate\ interface and its \OperationContextDelegate\ implementation, which centralize prompt execution logic and are consumed by new delegating runners (\DelegatingCreating\, \DelegatingRendering\, \DelegatingStreaming\, \DelegatingThinking\). It also adds new internal action types to support complex agent behaviors: \BranchingAction\ for conditional two-path outputs, \ConsumerAction\ and \SupplierAction\ for side-effect-only or input-less operations, and \MultiTransformationAction\ to handle actions with multiple inputs, state transitions, and blackboard management.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/support · high confidence

The GOAP planning module now includes an abstract OptimizingGoapPlanner class that enhances plan generation by handling unknown world conditions and pruning irrelevant actions. When the initial state contains unknown conditions, the planner evaluates potential variants to determine if the optimal plan changes; if so, it forces evaluation of the condition before planning. Additionally, the planner implements a pruning mechanism that filters the action set to only those present in the generated plans, reducing the search space for subsequent planning steps.

embabel-agent-api/src/main/kotlin/com/embabel/plan/goap · high confidence

The KeywordExtractor interface, which defines the contract for extracting keywords from text and calculating similarity scores based on match counts, has been relocated to the com.embabel.agent.api.common.primitive package. This change reorganizes the codebase structure without altering the interface's functionality or its scoring algorithm.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/primitive · high confidence

The MCP tool integration in the agent API has been restructured to improve startup performance and security. Tool groups now load tools lazily on first access rather than at construction time, ensuring that OAuth tokens are available in the security context before the MCP handshake occurs. A new \McpToolFactory\ interface provides consistent methods for creating single tools or 'UnfoldingTool' facades that group multiple MCP tools by name, regex, or custom filters. Additionally, a \ToolCallContextMcpMetaConverter\ has been introduced to control what metadata is passed to remote MCP servers, supporting allowlist, denylist, or pass-through modes to prevent sensitive data leakage.

embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/mcp · high confidence

The agent platform now exposes a comprehensive set of Spring Boot configuration properties under the \embabel.agent.platform\ prefix, managed by \AgentPlatformProperties\ and loaded via \AgentPlatformPropertiesLoader\. This includes dedicated configuration for process persistence (\embabel.agent.platform.persistence\), allowing users to enable durable checkpointing and select between \WAITING\ or \LIFECYCLE\ policies; process repository limits (\embabel.agent.platform.process-repository\); and a new threading model (\embabel.agent.platform.threading\) that supports virtual threads, platform threads, and optional sharing with the application's executor. Additionally, the platform now provides infrastructure injection capabilities for \ExecutingOperationContext\ and \Ai\ via prototype-scoped beans, and introduces a \SpringContextProvider\ to enable \@Provided\ injection of Spring beans directly into action methods.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/config · high confidence

The \embabel-agent-api\ module now includes new domain types to support structured content and external references. The \HasContent\ interface provides a standard way to access a single text component via a \content\ property, replacing previous naming conventions. Additionally, the module introduces \InternetResource\ and \InternetResources\ interfaces, allowing agents to expose structured lists of web links with URLs and summaries, which are automatically formatted for prompt contributions.

embabel-agent-api/src/main/kotlin/com/embabel/agent/domain/library · high confidence

The tool callback system has been refactored to introduce a unified \ToolLoopCallback\ interface with distinct \ToolLoopInspector\ (read-only observers for logging and metrics) and \ToolLoopTransformer\ (read-write modifiers for history compression) roles. This change adds a \SlidingWindowTransformer\ that manages context size while strictly preserving the required pairing of tool calls and results to prevent API errors, alongside a \ToolLoopLoggingInspector\ for detailed lifecycle tracking. A new lightweight \ToolCallInspector\ interface is also provided for observing individual tool executions without access to the full conversation history.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/callback · high confidence

The embabel-agent-openai module now uses the official openai-java SDK (OpenAIClient) instead of Spring AI's legacy REST client, which removes Spring's RestClient/WebClient from the HTTP path and makes the restClientBuilder and webClientBuilder constructor parameters unused (retained only for source compatibility). The factory now supports multiple OpenAI-compatible providers (OpenAI, DeepSeek, Mistral, Gemini, Atlas Cloud) with dedicated ByokSpec entry points and validates API keys on build. Options conversion is handled by CapabilityAwareOpenAiOptionsConverter, which proactively drops unsupported sampling parameters (temperature, top\_p, penalties) with warnings instead of failing requests, and maps token limits to maxCompletionTokens for the GPT-5 family. OpenAI-specific reasoning effort is forwarded via a dedicated converter that only applies to OpenAI's own endpoint, not to compatible providers.

embabel-agent-openai · high confidence

The Tika-based content reader in the RAG ingestion module now extracts structured, hierarchical sections from Markdown and HTML files instead of treating them as flat text. Markdown files are parsed by heading level (h1–h6) to build a nested document tree, and HTML files are similarly parsed by heading tags, falling back to plain-text parsing if no headings are found. This change improves the granularity of retrieved content for RAG queries by preserving document structure.

embabel-agent-rag/embabel-agent-rag-tika · high confidence

The framework now uses a pluggable \ActionMethodArgumentResolver\ strategy to inject parameters into action methods, supporting \OperationContext\, \Ai\, and values from the \Blackboard\ (with \@RequireNameMatch\ for ambiguous types) or platform context via \@Provided\. \DefaultActionMethodManager\ orchestrates this resolution and now supports dynamic cost/value computation via \@Cost\ methods. Additionally, \DefaultActionQosProvider\ enables configuring retry policies and delay behavior for actions through annotations and external properties, while \CurriedActionTool\ automatically curries action parameters based on current blackboard state to simplify tool exposure.

embabel-agent-api/src/main/kotlin/com/embabel/agent/api/annotation/support · high confidence

The streaming subsystem in the Spring AI support layer has been refactored to introduce a vendor-neutral \LlmMessageStreamer\ interface and a new \SpringAiLlmMessageStreamer\ implementation. This change decouples the core streaming logic from direct Spring AI \ChatClient\ usage, allowing tool-call inspectors to be invoked by Embabel's streaming tool loop rather than the adapter itself. Additionally, the existing \StreamingChatClientOperations\ class is now deprecated in favor of the new \StreamingLlmOperationsImpl\ via \StreamingLlmOperationsFactory\, signaling a migration path to the new vendor-agnostic architecture while maintaining backward compatibility for current users.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/springai/streaming · high confidence

The streaming subsystem has been restructured to introduce a vendor-neutral implementation of streaming LLM operations and a new capability detection mechanism. A new \StreamingCapabilityDetector\ now probes and caches whether specific \ChatModel\ instances support streaming, preventing unnecessary probe failures and improving performance by memoizing results. The core streaming logic has been moved into \StreamingLlmOperationsImpl\, which provides a unified, framework-agnostic pipeline for handling raw chunks, JSONL parsing, and tool loops. Additionally, an \InternalStreamingApi\ opt-in annotation has been added to mark these internal SPI components, ensuring they are not part of the public agent API.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/streaming · high confidence

The tool loop implementation has been restructured to extract shared logic into new support classes: ToolExecutionSupport handles individual tool execution and dynamic injection, while ToolLoopCallbackSupport centralizes inspector and transformer callbacks with robust error isolation. A new ParallelToolLoop implementation now executes multiple tool calls concurrently with configurable per-tool and batch timeouts, improving latency for I/O-bound operations. The DefaultToolLoop retains sequential execution but benefits from the shared support code, including consistent tool decoration, deduplication, and history transformation. These changes provide a more modular and observable tool execution framework without altering the core agent interaction model.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/loop/support · high confidence

The Agent Platform now prevents Model Context Protocol (MCP) client initialization failures from blocking application startup by filtering out Spring AI's default configuration and replacing it with a resilient implementation that logs errors but allows the application to proceed. Additionally, the platform introduces cache-backed agent process persistence, allowing users to configure durable state storage using the application's Spring CacheManager by setting \embabel.agent.platform.cache.provider=spring-cache\.

embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main · high confidence

The SpEL expression evaluator has been updated to handle missing variables more deterministically: if a SpEL condition references an object not present on the blackboard, it now evaluates to false instead of unknown, preventing confusing planner states. Additionally, the evaluator now supports dot-notation property access on Map objects (e.g., DynamicType payloads) via MapAccessor, and logs evaluation failures for null property access at DEBUG level rather than WARN.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/expression · high confidence

The Spring AI support layer has been updated to integrate with Spring AI 2.0, introducing native structured output support for providers like OpenAI and adding a new \SpringAiNativeStructuredOutputConfigurer\ hook for provider-specific option mapping. The \SpringAiLlmMessageSender\ now handles multi-generation responses (e.g., from Bedrock) by merging tool calls and text, and includes a retry mechanism to strip unsupported request parameters when models reject them. Observability is enhanced with \InstrumentedChatModel\ to emit \ChatModelCallEvent\ with the final augmented prompt, and tool execution is wrapped with \SpringAiToolCallbackListener\ to support \ToolCallInspector\ events. The \SpringAiLlmService\ replaces the deprecated \Llm\ class, and \SpringAiMcpToolFactory\ provides MCP tool integration.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/springai · high confidence

The \StreamingCapability\ interface in the \embabel-agent-api\ module is now deprecated and directs users to use \PromptRunner.StreamingCapability\ instead. This change is part of a broader effort to consolidate streaming functionality and remove deprecated methods, ensuring that developers access streaming capabilities through the updated \PromptRunner\ API rather than the standalone interface.

embabel-agent-api/src/main/kotlin/com/embabel/common/core/streaming · high confidence

The logging system in the agent API has been refactored to use an event-driven architecture, where implementation classes log at debug level and user-visible output is generated by event listeners. A new \LoggingAgenticEventListener\ listens for agent lifecycle and execution events (such as tool calls, state transitions, and LLM requests) to produce structured, human-readable logs. This change introduces a \LoggingPersonality\ interface and a \ColorPalette\ system, allowing users to customize the appearance and verbosity of log output through different personality implementations.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/logging · high confidence

The model provider now supports resolving LLM and embedding roles dynamically per call, allowing deployments to use role names (e.g., 'cheapest', 'documents') that map to specific models or providers based on the active user context. This enables bring-your-own-key (BYOK) applications to use user-supplied credentials for embeddings without requiring a restart, as the system resolves the correct model and provider at runtime. Configuration is now structured to support nested role-to-provider mappings, allowing different providers to be used for the same role based on the active credential. The system also includes improved error handling and discovery for local models, ensuring that locally served models are available immediately upon detection.

embabel-agent-api/src/main/kotlin/com/embabel/common/ai · high confidence

The platform now uses a single source of truth for classifying LLM failures and logging retry attempts across both the legacy Spring Retry and the new Spring Framework 7 retry templates. This ensures consistent behavior for rate limits, transient errors, and control-flow signals (such as replanning requests), while providing clear, operator-friendly log messages that identify the specific provider and attempt count.

embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/common · high confidence

The AWS Bedrock integration now includes an updated list of supported Claude models (including Claude 3.5 Sonnet V2, Claude 3.7 Sonnet, Claude Haiku 4.5, Claude Sonnet 4, and Claude Opus 4) across US, EU, and APAC regions, with current pricing and knowledge cutoff dates. This change also introduces a Spring Boot auto-configuration class (\AgentBedrockAutoConfiguration\) to automatically wire these model definitions into the application context.

embabel-agent-autoconfigure/models/embabel-agent-bedrock-autoconfigure/src/main/resources · high confidence

The Gemini model definitions have been refreshed to include the latest stable and preview models, specifically adding the Gemini 3.5 Flash, Gemini 3.1 family (including Flash Lite, Pro Preview, and Pro Preview with Custom Tools), and the Gemini 3 Flash Preview. The registry also now features the current generation Gemini 2.5 models (Pro, Flash, and Flash Lite). Conversely, the retired Gemini 2.0 models (Flash and Flash Lite) have been marked as deprecated with clear guidance to migrate to the newer 3.5 and 3.1 variants, as Google shut down the 2.0 endpoints.

embabel-agent-api/src/main/java/com/embabel/agent/api/models · high confidence

The core validation data types—ValidationError, ValidationResult, ValidationSeverity, and ValidationLocation—have been moved from the SPI to the common/core module for reuse across the platform. ValidationResult now includes a getHighestSeverity() helper to determine the worst-case severity (CRITICAL \> ERROR \> WARNING \> INFO) and a VALID singleton for success cases. ValidationError instances carry a structured code, message, severity, and optional location. A new ValidationErrorCodes class provides well-known constants for agent validation issues (e.g., EMPTY\_AGENT\_STRUCTURE, MISSING\_GOALS, DUPLICATE\_ACTION\_NAME, INVALID\_ACTION\_SIGNATURE, INVALID\_CONDITION\_SIGNATURE, NO\_ACTIONS\_TO\_GOALS, GOAL\_ACTION\_NOT\_FOUND, MISSING\_ACTION\_ANNOTATION), enabling consistent, machine-readable error reporting for agent structure and action/condition configuration.

embabel-agent-api/src/main/kotlin/com/embabel/common/core/validation · high confidence

The MCP server now closes Server-Sent Events (SSE) connections before Tomcat's graceful shutdown phase begins, preventing a 30-second stall on exit. A new \McpSseShutdownConfiguration\ listens for the Spring \ContextClosedEvent\ and explicitly calls \closeGracefully\ on the \WebMvcSseServerTransportProvider\ with a 5-second timeout, ensuring the application terminates cleanly without waiting for idle SSE keep-alives.

embabel-agent-mcp/embabel-agent-mcpserver · high confidence

Added AgentApiTestApplication for integration testing; Added FakeEmbeddingModel for testing; Added Java contract tests for ToolCallOutcomes; Added Java example tests for the Star News Finder agent; Added Java interoperability tests for Chatbot API; Added Java interoperability tests for McpToolFactory; Added Java interoperability tests for UnfoldingTool factory methods; Added Java interoperability tests for async, prompt runner, and rendering components; Added Java interoperability tests for the termination API; Added Java interoperability tests for the tooling API; Added Java unit tests for FakeOperationContext; Added Java-specific tests for agent annotation support; Added architecture tests for dependency rules and thread safety; Added end-to-end integration tests for the agent platform; Added integration test for Bedrock auto-configuration; Added integration test support for mocking LLM operations; Added integration tests for AgentPlatformProperties migration and test configuration for embeddings; Added integration tests for Anthropic model features; Added integration tests for human-in-the-loop (HITL) agent workflows; Added integration tests for the BYOK starter's boot and credential resolution; Added test configuration for fake LLM services; Added test coverage for agent core components; Added test coverage for autonomy agent lifecycle and execution; Added test coverage for file tooling and modification tracking; Added test coverage for observability auto-configuration and filters; Added test data for movie ratings; Added test fixtures for multi-goal agent scenarios; Added test models for Java form binding; Added test resource configurations and reference data for embabel-agent-api; Added tests for @State class execution, validation, and planning integration; Added tests for A\* planner action selection and unreachable goal logging; Added tests for A2A server integration and streaming support; Added tests for AgentInvocation, SupervisorInvocation, and UtilityInvocation; Added tests for Anthropic model loading, Opus 4.8 integration, and usage extensions; Added tests for Bedrock model loading and configuration; Added tests for Blackboard and Agent Process tools; Added tests for Blackboard, LLM invocation history, and process ID generation; Added tests for ConsensusBuilder workflow logic; Added tests for DeepSeek auto-configuration; Added tests for DefaultValidationPromptGenerator; Added tests for DelegatingCreating and DelegatingRendering; Added tests for GOAP planning system components; Added tests for HITL awaitable tool patterns and request types; Added tests for HybridUtilityPlanner behavior; Added tests for LLM reference provider functionality; Added tests for LLM retry logic, context propagation, and streaming operations; Added tests for LLM service construction and retry configuration; Added tests for MCP tool group initialization and metadata context conversion; Added tests for MathTools implementation and behavior; Added tests for OutputChannel combination and multicast behavior; Added tests for PromptTransformer DSL support; Added tests for PropertyFilter matching logic; Added tests for RepeatUntil and RepeatUntilAcceptable workflow builders; Added tests for ScatterGather and SimpleAgent workflow builders; Added tests for SpEL expression evaluation and agent action preconditions; Added tests for Spring AI integration components; Added tests for TemplatedPromptRunnerBuilder; Added tests for ThinkingPromptRunnerOperationsImpl; Added tests for ToolLoopConfiguration property binding and defaults; Added tests for TypedTool functionality; Added tests for UnfoldingTool shortcut dispatch and core behavior; Added tests for agent action delay policies; Added tests for agent and action early termination behaviors; Added tests for agent event and observability instrumentation; Added tests for agent invocation and supervisor orchestration; Added tests for agent platform auto-configuration resilience and cache-backed persistence; Added tests for agent platform configuration and wiring; Added tests for agent process snapshot persistence components; Added tests for agent process termination, thread safety, cost aggregation, and action retry behavior; Added tests for agent validation and deployment scenarios; Added tests for agentic tool infrastructure; Added tests for annotation support utilities; Added tests for chat agent session creation, blackboard formatting, and conversation status; Added tests for chat asset storage, message serialization, and conversation management; Added tests for chat support components; Added tests for domain library content assets and prompt contributions; Added tests for event listener error recovery and event serialization; Added tests for experimental injection utilities; Added tests for form processing, binding, and generation; Added tests for global guardrails registry configuration and integration; Added tests for guardrail configuration and token budget validation; Added tests for parallel tool execution and inspector exception isolation; Added tests for persistent AgentProcessRepository assembly and behavior; Added tests for polymorphic state handling and state transition events; Added tests for streaming capability detection and probing; Added tests for subagent execution and composition patterns; Added tests for subagent execution patterns; Added tests for the AI model provider and role resolution logic; Added tests for the FactChecker agent example; Added tests for the agent DSL builder and parallelization utilities; Added tests for the streaming tool loop; Added tests for thinking block extraction and PromptRunner integration; Added unit test utilities for agent testing; Added unit tests for AgentTool, GoalTool, and PerGoalToolFactory; Added unit tests for AppleScriptTools; Added unit tests for FakePromptRunner and OperationContext; Added unit tests for FileArtifact and UserInput serialization; Added unit tests for Gemini model constants and streaming builder; Added unit tests for HITL tool classes and WaitFor utility; Added unit tests for Plan class metrics and formatting; Added unit tests for Spring AI streaming components; Added unit tests for ValidationResult and validation severity logic; Added unit tests for agent API common components; Added unit tests for agent API support classes; Added unit tests for agent tool-loop policies and execution logic; Added unit tests for agent tooling components; Added unit tests for core agent configuration and metadata classes; Added unit tests for logging utilities and personality formatters; Added unit tests for prompt persona and formatting components; Added unit tests for tool loop callbacks and sliding window transformer; New integration test utilities and test doubles for the agent platform.

This change introduces the Maven POM definitions for the embabel-agent modules, establishing the project's modular structure and dependency graph. It explicitly declares dependencies for core components (API, A2A, Anthropic, MCP Server, Netty Client, Observability, Shell, Platform) and their respective auto-configuration modules, including specific model providers (Anthropic, Bedrock, BYOK, DashScope, Deepseek, Docker, Gemini, Google GenAI). The POMs reflect a migration to Spring Boot 4 and Spring AI 2.0, incorporating necessary adjustments such as pinning spring-retry version 2.0.13, adding explicit test dependencies for split Boot 4 modules (e.g., spring-boot-webmvc-test, spring-boot-security, spring-boot-micrometer-tracing), and declaring specific client libraries like anthropic-java-client-okhttp and a2a-java-sdk-spec to support the underlying frameworks.

(dependencies) · high confidence

Added documentation for the Embabel Agent Framework and its planning system; Added placeholder for embabel-agent-a2a resources; Initial project scaffolding and documentation.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 71 → 68 (-3.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 92 → 92 (-0.0)
• Architecture 100 → 79 (-20.1)
• Maturity 78 → 72 (-5.9)
• Readiness 66 → 59 (-7.2)
• Security 65 → 70 (+5.2)
• Domain Modelling 100 → 100 (+0.0)
• Performance 100 (new)

• Change coupling: BranchingAction.kt ↔ TransformationAction.kt (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/common/support/BranchingAction.kt)
• ClassTooLong: AgentMetadataReader (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/annotation/support/AgentMetadataReader.kt)
• Duplicated block (16 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/DomainTypeInputSchema.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Hotspot: embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/logging/LoggingAgenticEventListener.kt (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/logging/LoggingAgenticEventListener.kt)
• Hotspot: embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/loop/support/ParallelToolLoop.kt (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/loop/support/ParallelToolLoop.kt)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• Off-boarding risk: anonymized user #4
• Off-boarding risk: anonymized user #5
• Repeated repair: embabel-agent-autoconfigure/models/embabel-agent-deepseek-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/deepseek/DeepSeekModelsConfig.kt (embabel-agent-autoconfigure/models/embabel-agent-deepseek-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/deepseek/DeepSeekModelsConfig.kt)
• Repeated repair: embabel-agent-autoconfigure/models/embabel-agent-google-genai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/googlegenai/GoogleGenAiModelsConfig.kt (embabel-agent-autoconfigure/models/embabel-agent-google-genai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/googlegenai/GoogleGenAiModelsConfig.kt)
• Repeated repair: embabel-agent-autoconfigure/models/embabel-agent-mistral-ai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/mistralai/MistralAiModelsConfig.kt (embabel-agent-autoconfigure/models/embabel-agent-mistral-ai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/mistralai/MistralAiModelsConfig.kt)
• Scanner failed to run — not a clean result
• TodoComment (embabel-agent-api/src/main/kotlin/com/embabel/common/ai/model/ConfigurableModelProvider.kt)

• Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/DomainTypeInputSchema.kt)
• Duplicated block (16–17 lines × 2) (embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/autoconfigure/platform/QuiteMcpClientAutoConfiguration.java)
• Duplicated block (7 lines × 2) (embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/autoconfigure/platform/QuiteMcpClientAutoConfiguration.java)
• FileTooLong: model/ConfigurableModelProvider.kt (embabel-agent-api/src/main/kotlin/com/embabel/common/ai/model/ConfigurableModelProvider.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Hotspot: embabel-agent-observability/src/main/java/com/embabel/agent/observability/tracing/ChatModelObservationFilter.java (embabel-agent-observability/src/main/java/com/embabel/agent/observability/tracing/ChatModelObservationFilter.java)
• Medium: security finding (details withheld)
• No ADRs found
• Off the main sequence: embabel-agent-ai
• Off the main sequence: embabel-agent-api
• Off the main sequence: embabel-agent-cache-core
• Off the main sequence: embabel-agent-mcpserver
• Off the main sequence: embabel-agent-openai
• Off the main sequence: embabel-agent-platform-autoconfigure
• Off-boarding risk: anonymized user #5
• Off-boarding risk: anonymized user #4
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• …and 4 more

• 23 commits — 17 feature/other, 6 fixes

• embabel-agent-api/src — 10 commits
• embabel-agent-autoconfigure/models — 4 commits
• (root) — 3 commits
• .github/workflows — 1 commit
• embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure — 1 commit
• embabel-agent-cache/embabel-agent-cache-core — 1 commit
• embabel-agent-common/embabel-agent-ai — 1 commit
• embabel-agent-openai/src — 1 commit
• embabel-agent-skills/src — 1 commit

• fix: Feature: native structured output refinements — strict mode, schema fixes (#2027)
• fix: Fix Podman engine and tests (#2017)
• fix: Fix(security): upgrade Netty to 4.2.17.Final (#2018)
• fix: Fix: apply OpenAiHttpClientBuilderCustomizer in OpenAiCompatibleModelFactory (#2030)
• fix: fix validation responsibility boundaries (#1996)
• fix: fix: honor nested Jackson annotations in tool schemas (#1940)
• change: A locally served model is usable when it appears, not after a restart (#2046)
• change: A test class declared inside a backticked test name breaks every Spring context on JDK 25 (#2042)
• change: A tool's argument list says what it accepts, so a wrong name can be named (#2012)
• change: Add durable asset storage contracts (#1957)
• change: An embedding default can name a role, and resolve per call (#2041)
• change: Avoid log spamming as Beans may not be Agent (#2016)
• change: Feature(cache): add JCache-backed agent process persistence with MVC reference test (#2004)
• change: Feature(cache): autoconfigure cache-backed agent process persistence (#2019)
• change: Forward a configured OpenAI reasoning effort from LlmOptions (#2063)
• change: Generate llms.txt based on asciidoc/reference/reference.adoc (#2036)
• change: Handle every criteria an embedding model can be asked for (#2044)
• change: LM Studio no longer ships a stale OpenAI model catalog (#2065)
• change: Let the deployment default LLM name a role (#2031) (#2032)
• change: Prepare 1.5.2 (#2020)
• …and 3 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

embabel/embabel-agent was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.