embabel/embabel-agent
66.7
Adequate · 14 November 2026
116k
lines of production code
Kotlin
with Java
5
measurements over time
What this system is
Features
API-driven early termination for agents and actions
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
Add Cloudflare Workers AI decision models as a System One provider
Applications can now use Cloudflare Workers AI for decision and classification tasks. This change introduces the CLEF models (CLEF, CLEF Flash, CLEF Omni) and the Jev model as decision services, automatically registered via Spring Boot auto-configuration when the Cloudflare integration is on the classpath. Users must provide a Cloudflare API token and account ID (via environment variables or configuration properties) to enable the provider, which then exposes these models as injectable \DecisionService\ beans.
embabel-agent-cloudflare · high confidence
Add LuceneStatistics data class for RAG service metrics
A new LuceneStatistics data class has been introduced to expose detailed state metrics for the Lucene RAG service. This class implements ContentElementRepositoryInfo and provides specific statistics including chunk count, document count, content element count, average chunk length, vector weight, and the persistent index path, enabling better visibility into the search index's current configuration and health.
embabel-agent-rag-lucene · high confidence
Add TypeSafe decision model auto-configuration
The \embabel-agent-typesafe-autoconfigure\ module now provides Spring Boot auto-configuration for TypeSafe decision services. It registers a \TypeSafeModelFactory\ and creates a \DecisionService\ bean for each model defined in the bundled \typesafe-models.yml\ catalog (currently exposing the \jev-latest\ model). The configuration binds connection settings under \embabel.agent.platform.models.typesafe\ (with a default base URL of \https://api.typesafe.ai\ and a 1 MiB response limit) and requires an API key via the \TYPESAFE\_API\_KEY\ environment variable or the \embabel.agent.platform.models.typesafe.api-key\ property. Applications can override the default model or specific catalog entries by defining their own beans, and the system respects the application's shared REST client builder and observation registry.
embabel-agent-autoconfigure/models/embabel-agent-typesafe-autoconfigure · high confidence
Add structured response format support
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
Add support for Alibaba Cloud DashScope Qwen models
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
Add support for Z.ai (Zhipu AI) GLM models
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
Added progress event listener for tool and LLM activity highlighting
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
Anthropic integration upgraded to Spring AI 2.0 with native thinking and prompt caching support
The Anthropic module has been migrated to Spring AI 2.0, replacing the legacy REST client with the official Anthropic Java SDK. This update introduces native support for Claude 5.x adaptive thinking, including proper extraction of reasoning blocks and handling of model-specific constraints (e.g., omitting thinking parameters for Claude 5.1+). It also adds prompt caching configuration to reduce latency and costs for long contexts. Additionally, a new HTTP interceptor fixes content block ordering in assistant messages to prevent API errors on newer accounts, and the module now supports Bring Your Own Key (BYOK) initialization without requiring a Spring context.
embabel-agent-anthropic/src/main · high confidence
Auto-configuration for local Docker-hosted AI models
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
Autoconfigure cache-backed agent process persistence
Applications can now make agent process state durable by using a Spring CacheManager as the backing store. By setting embabel.agent.platform.cache.provider=spring-cache, the platform automatically registers a cache-backed snapshot store, provided that agent process persistence is enabled (embabel.agent.platform.persistence.enabled=true). This configuration includes a safety check for atomic compare-and-set capabilities, which are required for multi-node safety but can be disabled for single-node deployments.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/autoconfigure/platform/cache · high confidence
Automatic registration of decision and classification services via configuration
The platform now automatically builds a \DecisionServiceRegistry\ by scanning the application context for \ClassificationService\ and \DecisionModelProvider\ beans. Users can configure which specific models serve as the default or handle specific roles (e.g., \support-triage\) using the \embabel.models.decision\ and \embabel.models.classification\ configuration prefixes. Additionally, a new \embabel.agent.platform.decisions.capture-content\ property allows users to enable logging of decision request and response content for debugging, with a warning that this should not be used in production due to potential exposure of confidential data.
embabel-agent-platform-autoconfigure · high confidence
BYOK deployments can now start without a provider API key
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
Cache-backed persistence for agent processes
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
Centralized model registry for supported LLM providers
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
Declarative OpenAI model configuration with Responses API support
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. Also in this area: 1 commit (0 fixes) modifying embabel-agent-autoconfigure/models/embabel-agent-byok-autoconfigure, embabel-agent-autoconfigure/models/embabel-agent-openai-autoconfigure.
embabel-agent-autoconfigure/models/embabel-agent-openai-autoconfigure · low confidence · unverified
Embedding operations now track usage and emit observability events
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
Enforce Spring Security on MCP agent tools
The MCP server now supports fine-grained access control for agent actions exposed as remote tools. Developers can annotate \@Action\ methods or entire \@Agent\ classes with \@SecureAgentTool\, providing Spring Security SpEL expressions (such as \hasAuthority\ or \hasRole\) that are evaluated before the tool executes. If the expression fails or no authentication is present, the call is denied with a 403 error at the transport layer, ensuring that sensitive agent capabilities are protected by the application's existing security policies.
embabel-agent-mcp/embabel-agent-mcpserver · high confidence
Enhanced HTTP observability and cross-thread MDC correlation
The observability auto-configuration now includes two new components to improve debugging and tracing. First, an observation filter enriches HTTP server traces with request headers, query parameters, and body content (when caching is enabled), with sensitive headers like Authorization masked for security. Second, a context propagation registrar ensures MDC correlation keys (such as run\_id and agent.name) are correctly carried across thread boundaries during asynchronous agent execution, preventing log lines on worker threads from appearing empty.
embabel-agent-observability-autoconfigure · high confidence
Expose MCP server health status via Spring Boot Actuator
The MCP server's operational status is now exposed through the standard Spring Boot Actuator health endpoint at /actuator/health under the 'mcpServer' component. This allows users and monitoring systems to verify if the server is ready, initializing, or down, and provides detailed context including the current mode, number of tools, initialization state, and any reported issues.
embabel-agent-mcpserver-autoconfigure · high confidence
Extract condition-based planning types for GOAP and other planners
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
Foundation for durable agent process persistence and HITL resume
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
Global guardrails configuration and validation logic
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
Google Gemini model support via YAML-driven autoconfiguration
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
Guardrail framework for validating user input and LLM responses
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
Human-in-the-Loop (HITL) support for agent processes
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
Initial documentation scaffold and build tooling for embabel-agent-docs
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
Introduce A2A server module with JSON-RPC and streaming endpoints
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
Introduce AWS Bedrock model auto-configuration and registration
The system now automatically detects and registers AWS Bedrock language and embedding models at startup. A new auto-configuration class wires up the necessary AWS clients and a shared tool-calling manager, while a YAML-based model loader reads definitions for Claude (US, EU, APAC regions) and Titan/Cohere embedding models, validating their IDs and regions. This allows users to select Bedrock models via standard configuration properties without manual bean setup.
embabel-agent-autoconfigure/models/embabel-agent-bedrock-autoconfigure · high confidence
Introduce Agent Skills module with embedding-based selection and sandboxed script execution
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
Introduce BYOK provider detection and embedding validation
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
Introduce Google GenAI (Gemini) model support with autoconfiguration
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
Introduce MCP server execution modes and tool export infrastructure
The MCP server module now supports both synchronous and asynchronous execution modes, implemented via new \SyncServerStrategy\ and \AsyncServerStrategy\ classes that delegate tool, resource, and prompt management to the underlying \McpSyncServer\ or \McpAsyncServer\ instances. A new \McpToolExport\ interface provides a programmatic way to export tools from \ToolObject\ or \LlmReference\ sources, applying configurable naming strategies and filtering to avoid conflicts. Domain types in \Types.kt\ define the execution modes (\SYNC\, \ASYNC\) and capabilities, while \McpServerInitializationTracker\ enables health and readiness checks by tracking the server's initialization state.
embabel-agent-mcpserver · high confidence
Introduce OCI Generative AI model support with Spring AI 2.0 compatibility
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
Introduce OutputChannel, Actor, and multimodal content abstractions for agent interactions
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
Introduce SPI for durable agent process persistence and snapshots
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
Introduce System One protocol support for decision models
This change adds the System One protocol implementation to the agent system, enabling decision models to be served and consumed via a standardized HTTP interface. It introduces a new \SystemOneEndpoint\ configuration class for managing provider addresses, timeouts, and response limits, alongside a \SystemOneModelFactory\ to build \DecisionService\ instances for specific models. The implementation includes a \SystemOneTransport\ layer for HTTP communication, a \SystemOneBinding\ interface to allow customizing request/response layouts (with a \STANDARD\ binding for the default protocol layout), and a \GuardedObservation\ utility to ensure telemetry does not interfere with call results. Users can now integrate decision models that adhere to the System One specification, supporting both remote providers and local endpoints like Ollama.
embabel-agent-systemone · high confidence
Introduce TypeSafe provider integration for decision and classification services
This change adds the \embabel-agent-typesafe\ module, providing a new AI provider integration for the TypeSafe platform. It introduces \TypeSafeModelFactory\ to build \DecisionService\ instances (supporting both classification and proposition assessments) backed by TypeSafe models, defaulting to the \jev-latest\ model. The implementation includes a guarded HTTP client (\GuardedTypeSafeApi\) that enforces strict response validation, disables retries, and handles credential resolution per request. Additionally, \TypeSafeQuestionSets\ maps Embabel decision specifications to TypeSafe native question types (choice, proposition, rating) and translates provider responses back into Embabel decision results, ensuring provider-neutral contracts for callers.
embabel-agent-typesafe · high confidence
Introduce agent cache SPI and Spring Cache adapter
The agent cache module now provides a standardized integration layer for persistent agent state, allowing data to outlive individual execution nodes. This change introduces the \AgentCacheProvider\ SPI, which defines capabilities such as atomic compare-and-set, secondary indexing, and time-to-live support, enabling consumers to request specific guarantees from the backend. It also includes a \SpringCacheAgentCacheProvider\ that adapts any Spring \CacheManager\ (e.g., Caffeine, Redis, Hazelcast) to this SPI, allowing users to leverage existing Spring cache configurations for agent state storage while handling versioning and index emulation internally.
embabel-agent-cache-core · high confidence
Introduce autoconfiguration for custom OpenAI-compatible LLM models
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
Introduce blackboard persistence serialization framework
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
Introduce composable property filtering with in-memory evaluation
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
Introduce core agent model and execution infrastructure
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
Introduce declarative, YAML-driven Anthropic model auto-configuration
The Anthropic module now registers models automatically from a new \anthropic-models.yml\ configuration file, eliminating the need for manual bean setup. This change introduces a Spring Boot auto-configuration (\AgentAnthropicAutoConfiguration\) that loads model definitions—including metadata like pricing, knowledge cutoffs, and thinking mode budgets—and registers them as \LlmService\ beans. It also adds support for Anthropic-specific features such as prompt caching (with usage extensions for cache read/creation tokens), extended thinking mode configuration, and native structured output metadata. The configuration is driven by \AnthropicProperties\ (prefix \embabel.agent.platform.models.anthropic\) for API key and base URL, and includes validation for model parameters like temperature and token limits.
embabel-agent-autoconfigure/models/embabel-agent-anthropic-autoconfigure · high confidence
Introduce in-memory process and context repositories with bounded eviction
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
Introduce interactive Embabel Agent Shell module
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
Introduce unified observability for Embabel AI Agents
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
Introduce vendor-neutral streaming tool loop
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
Introduces a configurable RAG response enhancement pipeline
The RAG pipeline now includes a pluggable enhancement stage that processes search results before returning them to the user. This pipeline applies a sequence of enhancers—deduplication, chunk merging, optional result compression, LLM-based reranking, and quality filtering—to improve relevance and reduce noise. An adaptive execution mode allows the pipeline to skip expensive enhancers if quality is already high or if latency limits are reached, and the entire process emits detailed events for monitoring.
embabel-agent-rag/embabel-agent-rag-pipeline · high confidence
Introduces configurable Netty-backed HTTP clients for AI model interactions
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
Introduces internal observability instrumentation API for agent actions and LLM calls
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
Introduces multimodal message support and durable asset tracking for chat conversations
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
Introduction of User and UserService interfaces for identity management
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
Introduction of core planning domain model and interfaces
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
JDBC persistence for agent process snapshots
Agent processes can now be persisted to a relational database using JDBC. By setting \embabel.agent.platform.persistence.provider=jdbc\ and providing a \DataSource\, the platform automatically registers a \JdbcAgentProcessSnapshotStore\ backed by the \agent\_process\_snapshots\ table (schema provided in \schema.sql\). This enables durable state across application restarts and allows processes to resume on different pods sharing the same database, with optimistic concurrency control to prevent data loss during concurrent updates.
embabel-agent-autoconfigure/embabel-agent-jdbc-autoconfigure, embabel-agent-jdbc · high confidence
Java streaming support via new builder pattern
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
Java wrapper for HITL wait operations added
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
LLM-backed decision and classification services
The decision and classification subsystem now uses Large Language Models to answer questions. This location introduces the LlmDecisionService, which implements the DecisionService and ClassificationService contracts by sending prompts to a chat model and parsing structured JSON responses for classification, proposition assessment, and multi-question decision sets. It also provides OperationBoundServices, which select these LLM-backed services from the registry and bind them to the current workflow observation for tracing.
embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/decision, embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/decision · high confidence
LM Studio model auto-configuration and dynamic discovery
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
Local ONNX embedding service with automatic model caching
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
Lucene RAG now supports high-dimensional vectors and persists full content hierarchies
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
MCP server health status exposed via Spring Boot Actuator
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
MiniMax AI models are now available as first-class LLM providers
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
Mistral AI model support added to the agent platform
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
New A2A auto-configuration for Agent-to-Agent endpoints
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. Also in this area: 1 commit (0 fixes) modifying embabel-agent-a2a, embabel-agent-autoconfigure/embabel-agent-a2a-autoconfigure.
embabel-agent-autoconfigure/embabel-agent-a2a-autoconfigure/src/main, embabel-agent-autoconfigure/embabel-agent-a2a-autoconfigure/src/test · medium confidence · unverified
New AgentScopeBuilder interface for constructing agent scopes
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
New AgenticTool API with Playbook and State-based orchestration
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
New AppleScript execution tool for macOS agents
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
New Blackboard Tools for Agent Context Access
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
New ConsensusBuilder for multi-model result aggregation
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
New Kotlin DSL for defining agents, actions, and execution flows
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
New LLM-driven RAG pipeline components for HyDE and contextual compression
The RAG pipeline now includes two new enhancers: \PromptedContextualCompressionEnhancer\, which uses an LLM to compress retrieved chunks based on the user's query (removing irrelevant content and reducing token usage), and \LlmHyDEQueryGenerator\, which generates hypothetical document embeddings (HyDE) to improve retrieval accuracy. These components allow the pipeline to dynamically refine search results and query formulation using language model capabilities.
embabel-agent-rag-pipeline · high confidence
New LlmReference types and eager search capability
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
New MathTools class exposes arithmetic and statistical operations via an UnfoldingTool
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
New ONNX embedding model support with automatic configuration
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
New PromptCondition for LLM-based condition evaluation
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
New RAG ingestion pipeline and entity-aware search filtering
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
New REST API endpoints for agent process management and platform information
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
New SPI interfaces for agent extensibility and BYOK support
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
New ScatterGather and SimpleAgent workflow builders
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
New Spring Boot auto-configuration for agent platform and decision services
The agent platform now automatically registers core infrastructure components via Spring Boot auto-configuration. This includes the main agent platform setup, cache-backed persistence for agent processes (via AgentCacheProvider and CacheSnapshotStore), and the registration of LLM-backed decision services through the DecisionServiceRegistry. Users benefit from immediate availability of these services without manual bean configuration.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/resources/META-INF/spring · high confidence
New Spring injection utilities for cascading dependency injection
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
New StringTransformer utility for chaining string transformations
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
New WorkflowBuilder API for structured agent construction
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
New agent invocation API with supervisor and utility patterns
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
New agent process monitoring tools
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
New agent tooling framework for goal-based execution
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
New agent validation pipeline with structural and goal-path checks
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
New agentic tool orchestration and execution primitives
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
New annotation model for tools, subagents, and parameter injection
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
New annotations for defining and exporting agent goals
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
New auto-configured security for MCP server endpoints and agent tools
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
New chat agent infrastructure and default persona
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
New chat support components: event publishing, asset tracking, and token-budget formatting
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
New classification and decision service contracts with structured output support
This change introduces new service contracts and data models for AI-driven classification and decision-making. The \ClassificationService\ and \DecisionService\ interfaces allow applications to classify text into categories or assess propositions, with results returned as structured \ClassificationResult\ and \PropositionResult\ objects. \ClassificationSpec\ is now defined as a decision spec with a single choice question, enabling unified handling. The diff also adds \LlmAutoConfigMetadata\ and \ProviderInitialization\ to support autoconfiguration of LLM providers, and includes \jsonSchemaSupport\ utilities to normalize JSON schemas for structured output, ensuring consistent provider integration. Also in this area: 1 commit (0 fixes) modifying embabel-agent-ai, embabel-agent-autoconfigure/models/embabel-agent-bedrock-autoconfigure.
embabel-agent-ai · medium confidence · unverified
New coding tools for CI, Git, and API reference
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
New console-based chat interface and output channel
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
New domain models for content assets and research in embabel-agent-domain
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
New domain types for user input and system output
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
New event system for agent lifecycle, LLM/Embedding usage, and ranking decisions
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
New file tools with change tracking and content sanitization
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
New form generation and binding system for Java and Kotlin classes
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
New interactive shell starter for Embabel Agent applications
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
New internal test support module with DSL helpers and fake AI configuration
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
New observability auto-configuration module for tracing, metrics, and MDC
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
New persona and prompt contributor templates added
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
New progressive tool hierarchy with UnfoldingTool and NestedTool interfaces
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
New prompt elements for controlling tool call limits
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
New promptTransformer DSL function for building LLM-based actions
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
New ranking and logical expression interfaces
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
New shell auto-configuration module for interactive agent mode
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
New structured output, classification, and decision service APIs
This release introduces new APIs for structured LLM output and decision-making. The \JacksonOutputConverter\ now uses Jackson 3 and includes a lenient parser that safely fixes malformed escaped quotes in LLM responses without corrupting valid JSON. A new \FilteringJacksonOutputConverter\ allows property filtering via predicates, and \StreamingJacksonOutputConverter\ enables real-time JSONL streaming with integrated thinking-block detection. Additionally, new \CategoryMapping\ and \DecisionProjection\ classes provide structured interfaces for classification and decision services, allowing users to map LLM outputs to typed results and project decision answers onto custom data structures.
embabel-agent-common/embabel-agent-ai · high confidence
New themed logging personalities for agent events
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
New thinking capability infrastructure for LLM reasoning extraction
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
New utility-based and hybrid planning strategies for agent action selection
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
New workflow loop primitives for iterative generation and evaluation
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
RAG ingestion and search framework modularized with new core abstractions
The RAG core library has been restructured into a modular framework, introducing new interfaces and models for document ingestion and retrieval. Users can now leverage a hierarchical content model (ContentRoot, Section, LeafSection) and a dedicated ContentChunker to split documents into structured chunks with preserved navigation paths. Ingestion is handled by a new Ingester interface and HierarchicalContentReader, which supports parsing directories and fetching content via composable ContentMappers. Search capabilities are enhanced with a new EntityFilter for label-based entity matching and a ResultExpander that appends neighboring chunks to search hits for better context. Structural metadata (e.g., root document ID, section titles) is now promoted to a dedicated ChunkStructure type for robust navigation and filtering.
embabel-agent-rag-core · high confidence
Support for rendering system prompts from templates
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
User-configurable logging personality via @EnableAgents
The platform now allows users to define the logging style (personality) directly through the loggingTheme attribute on the @EnableAgents annotation. An EnvironmentPostProcessor runs at the highest precedence during startup to detect this attribute and injects the value as the embabel.agent.logging.personality property, ensuring the chosen logging theme is applied before other components initialize.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/config/annotation/spi · high confidence
User-configurable logging themes and auto-configuration registration
Users can now customize the style of application log messages by selecting from predefined themes (Star Wars, Severance, Colossus, Hitchhiker's Guide, and Monty Python) via the \embabel.agent.logging.personality\ configuration property, with IDE support provided through new Spring configuration metadata. Additionally, the platform registers an \EnvironmentPostProcessor\ and an auto-configuration import filter to ensure these logging settings are applied correctly during the Spring Boot startup phase.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/resources/META-INF · high confidence
Behavioural changes
1 commit (0 fixes) modifying embabel-agent-a2a, embabel-agent-autoconfigure/embabel-agent-a2a-autoconfigure
A change to existing behaviour in embabel-agent-a2a, embabel-agent-autoconfigure/embabel-agent-a2a-autoconfigure — 1 commit, 33 files: “A2A client with OTel contextId propagation and server observability (\#2038)” (refs \#2038). Also in this area: Added placeholder for embabel-agent-a2a resources.
embabel-agent-a2a/src/main/resources · medium confidence · unverified
1 commit (0 fixes) modifying embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/hitl
A change to existing behaviour in embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/hitl — 1 commit, 6 files: “\#1550: Confirmation Guarded Tool (\#2094)” (refs \#1550, \#2094).
embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/hitl · medium confidence · unverified
3 commits (0 fixes) modifying embabel-agent-autoconfigure/models/embabel-agent-cloudflare-autoconfigure
A change to existing behaviour in embabel-agent-autoconfigure/models/embabel-agent-cloudflare-autoconfigure — 3 commits, 11 files: “Add Cloudflare Workers AI decision models as a System One provider (\#2146)”; “Share the strict decision model catalog loader (\#2166)”; “Share decision model catalog registration (\#2167)” (refs \#2146, \#2166, \#2167).
embabel-agent-autoconfigure/models/embabel-agent-cloudflare-autoconfigure · medium confidence · unverified
A\* GOAP planner handles unreachable goals with explicit logging
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
Agent API configuration restructured into dedicated application and platform property files
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
Agent Platform auto-configuration and resilient MCP client support
The Agent Platform now bootstraps its core services through a new \AgentPlatformAutoConfiguration\ that imports shared property loading, component scanning, and specific configurations for tools and embedding tracking. To prevent startup failures from Model Context Protocol (MCP) client issues, the platform introduces a filter that excludes Spring AI's default \McpClientAutoConfiguration\ and replaces it with a resilient \QuiteMcpClientAutoConfiguration\ that logs errors without blocking the application. Additionally, LLM-backed decision services are now auto-configured with configurable retry policies (max attempts, backoff) bound from \embabel.agent.platform.decisions.llm\, allowing applications to define named decision services that automatically retry model calls.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/autoconfigure/platform · high confidence
Autonomy module refactored to support flexible input bindings and goal approval
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
Configurable Netty HTTP client timeouts for AI model interactions
The application now uses a Netty-based HTTP client (Reactor Netty) for AI model communication by default, replacing the previous request factory approach. This change introduces configurable connection and read timeouts via the \embabel.agent.platform.http-client\ properties (defaulting to 25 seconds for connection and 5 minutes for read), allowing users to tune network behavior for Ollama and other model endpoints.
embabel-agent-netty-client-autoconfigure · high confidence
Configurable auto-scanning for Agent beans
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
Configurable tool loop execution and empty response handling
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
Conservative native structured output policy for provider-agnostic schema validation
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
Core agent execution engine and state management refactored
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
DeepSeek model support with configurable retry and shared HTTP client
The DeepSeek autoconfiguration module now registers DeepSeek model beans (chat, reasoner, v4-flash, v4-pro) as SpringAiLlmService instances, allowing users to interact with DeepSeek models via the standard agent interface. Configuration is controlled via the 'embabel.agent.platform.models.deepseek' prefix (with environment variable overrides), including API key, base URL, and retry behavior (max attempts, backoff). The implementation fixes a previous issue where retry properties were ignored by ensuring the configuration honors the specified retry settings and uses the shared platform HTTP client builder rather than creating its own, preventing content-encoding failures.
embabel-agent-autoconfigure/models/embabel-agent-deepseek-autoconfigure · high confidence
Deprecated annotation-based agent configuration in favor of properties
The @EnableAgents annotation and related constants (LoggingThemes, McpServers) are now marked for removal in version 0.3.1. Users should migrate from annotation attributes like loggingTheme and mcpServers to the new property-based configuration (embabel.agent.logging.personality) and standard Spring profile activation, as the annotation approach is being phased out in favor of idiomatic configuration.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/config/annotation · high confidence
Externalized default chat and prompt contribution templates
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
Internal refactoring of LLM operations and streaming interfaces
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
Introduce configurable policies for empty responses and missing tools in the tool loop
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
Introduces PromptExecutionDelegate and specialized action types for agent workflows
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
Introduction of OptimizingGoapPlanner with pruning and unknown-condition handling
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
KeywordExtractor interface moved to api.primitive package
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
MCP tool integration refactored for lazy loading and metadata security
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
Model providers can now configure their own HTTP connect and read timeouts
Model providers such as DeepSeek and Mistral AI can now specify distinct \connect-timeout\ and \read-timeout\ values under their own configuration prefix (e.g., \embabel.agent.platform.models.\<provider\>\). If a provider sets these timeouts, it uses a dedicated HTTP client transport rather than the shared global \http-client\ settings, ensuring that provider-specific latency requirements are met independently of the application-wide defaults.
embabel-agent-api/src/main/kotlin/com/embabel/agent/common · high confidence
New Spring configuration for agent platform properties, persistence, and threading
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
New domain interfaces for content and internet resources
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
New tool loop callback and inspection infrastructure
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
Ollama model autoconfiguration now supports multiple instances
The Ollama autoconfiguration module has been refactored to support connecting to multiple Ollama instances. Users can now configure multiple nodes via the \embabel.agent.platform.models.ollama.nodes\ property list, allowing the system to discover and register models from different Ollama servers (e.g., a local instance and a remote GPU server). The configuration logic automatically detects whether to use a single default URL, multiple explicit nodes, or a hybrid of both, and registers the discovered models with appropriate naming prefixes to distinguish their source nodes.
embabel-agent-autoconfigure/models/embabel-agent-ollama-autoconfigure · high confidence
OpenAI-compatible model factory and options conversion updated for Spring AI 2.0
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
RAG ingestion now parses Markdown and HTML into hierarchical sections
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
Refactored action method invocation with custom argument resolvers and QoS support
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
Refactored streaming implementation with vendor-neutral LlmMessageStreamer
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
Refactored streaming infrastructure with capability detection and vendor-neutral operations
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
Refactored tool execution into shared support classes with new parallel loop and callback infrastructure
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
Resolves conflicts between library logging defaults and user-supplied configurations
The platform now respects user-defined logging settings by introducing an environment post-processor that checks for existing user configurations before applying library defaults. If a user has explicitly set the \logging.config\ property or provided a \logback-spring.xml\ file, the platform skips its own logging setup, preventing conflicts. Otherwise, it automatically applies the default logging configuration specified in \agent-platform.properties\, ensuring consistent logging behavior without overriding user preferences.
embabel-agent-autoconfigure/embabel-agent-platform-autoconfigure/src/main/java/com/embabel/agent/logging · high confidence
SpEL expressions now return false for missing variables and support dot-notation map access
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
Spring AI 2.0 integration with native structured output and observability
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
StreamingCapability interface marked as deprecated
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
Structured event-driven logging with customizable personalities
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
Support for dynamic role-based model selection and bring-your-own-key embeddings
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
Unified LLM retry policy and logging
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
Updated Gemini model registry with latest versions and deprecated retired models
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
Validation model moved to common/core with structured error codes and severity levels
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
Test coverage
1 commit adding/updating tests in embabel-agent-api/src/test/java/com/embabel/agent/api/tool/hitl, embabel-agent-api/src/test/kotlin/com/embabel/agent/api/tool/hitl; 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 support for mocking LLM operations; Added integration tests for AgentPlatformProperties migration and test configuration for embeddings; 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 examples for horoscope and movie agent workflows; 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 integration components; Added tests for Blackboard and Agent Process tools; Added tests for Blackboard, LLM invocation history, and process ID generation; Added tests for Cloudflare Workers AI decision model integration; Added tests for ConsensusBuilder workflow logic; Added tests for DefaultValidationPromptGenerator; Added tests for DelegatingCreating and DelegatingRendering; Added tests for GOAP planning system components; Added tests for Google GenAI model constants; 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 filtering, logging, and decision consistency; 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 decision service configuration and integration examples; Added tests for decision service observation and configuration examples; Added tests for decision service selection and configuration examples; 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 provider-specific HTTP timeout configuration; 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 LLM-backed decision and classification services; 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.
Dependencies
Maven module structure and dependency declarations for Spring Boot 4 compatibility
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
Housekeeping
Added documentation for the Embabel Agent Framework and its planning system; Initial project scaffolding and documentation.
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 68 → 67 (-1.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 76 → 76 (-0.5)
- Architecture 80 → 78 (-1.3)
- Maturity 78 → 78 (+0.4)
- Readiness 60 → 57 (-3.2)
- Security 72 → 70 (-1.7)
- Domain Modelling 98 → 98 (+0.0)
- Performance 78 → 100 (+21.7)
Resolved (74)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/DomainTypeInputSchema.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/DomainTypeInputSchema.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/agentic/playbook/PlaybookToolInjectionStrategy.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/guardrails/llmOperationGuardRails.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/springai/streaming/StreamingChatClientOperations.kt)
- Duplicated block (10 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-lmstudio-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/lmstudio/LmStudioModelsConfig.kt)
- Duplicated block (10–11 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/agent/AgentTool.kt)
- Duplicated block (10–12 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/blackboard/BlackboardTools.kt)
- Duplicated block (11 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-dashscope-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/dashscope/DashScopeModelsConfig.kt)
- Duplicated block (11 lines × 2) (embabel-agent-rag/embabel-agent-rag-core/src/main/kotlin/com/embabel/agent/rag/ingestion/InMemoryContentChunker.kt)
- Duplicated block (11–13 lines × 3) (embabel-agent-autoconfigure/models/embabel-agent-google-genai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/googlegenai/GoogleGenAiModelLoader.kt)
- Duplicated block (12 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/springai/streaming/StreamingChatClientOperations.kt)
- Duplicated block (12 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-gemini-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/gemini/GeminiModelLoader.kt)
- Duplicated block (12 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-google-genai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/googlegenai/GoogleGenAiModelsConfig.kt)
- Duplicated block (12–13 lines × 2) (embabel-agent-rag/embabel-agent-rag-tika/src/main/kotlin/com/embabel/agent/rag/ingestion/HtmlContentParser.kt)
- Duplicated block (13 lines × 3) (embabel-agent-autoconfigure/models/embabel-agent-anthropic-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/anthropic/AnthropicModelsConfig.kt)
- Duplicated block (13–14 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/annotation/support/AgentMetadataReader.kt)
- Duplicated block (14 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/ToolLoopLlmOperations.kt)
- Duplicated block (14 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-minimax-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/minimax/MiniMaxModelsConfig.kt)
- Duplicated block (14–16 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/core/Blackboard.kt)
- …and 54 more
New (161)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/DomainTypeInputSchema.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/DomainTypeInputSchema.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/tool/agentic/playbook/PlaybookToolInjectionStrategy.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/guardrails/llmOperationGuardRails.kt)
- Duplicated block (10 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/springai/streaming/StreamingChatClientOperations.kt)
- Duplicated block (10 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-lmstudio-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/lmstudio/LmStudioModelsConfig.kt)
- Duplicated block (10 lines × 3) (embabel-agent-rag/embabel-agent-rag-core/src/main/kotlin/com/embabel/agent/rag/ingestion/InMemoryContentChunker.kt)
- Duplicated block (10–11 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/agent/AgentTool.kt)
- Duplicated block (10–12 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/tools/blackboard/BlackboardTools.kt)
- Duplicated block (11 lines × 2) (embabel-agent-rag/embabel-agent-rag-core/src/main/kotlin/com/embabel/agent/rag/ingestion/InMemoryContentChunker.kt)
- Duplicated block (11–13 lines × 3) (embabel-agent-autoconfigure/models/embabel-agent-google-genai-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/googlegenai/GoogleGenAiModelLoader.kt)
- Duplicated block (12 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/springai/streaming/StreamingChatClientOperations.kt)
- Duplicated block (12 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-gemini-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/gemini/GeminiModelLoader.kt)
- Duplicated block (12 lines × 2) (embabel-agent-rag/embabel-agent-rag-core/src/main/kotlin/com/embabel/agent/rag/ingestion/InMemoryContentChunker.kt)
- Duplicated block (12–13 lines × 2) (embabel-agent-rag/embabel-agent-rag-tika/src/main/kotlin/com/embabel/agent/rag/ingestion/HtmlContentParser.kt)
- Duplicated block (12–13 lines × 3) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/ToolLoopLlmOperations.kt)
- Duplicated block (13–14 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/api/annotation/support/AgentMetadataReader.kt)
- Duplicated block (14 lines × 2) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/ToolLoopLlmOperations.kt)
- Duplicated block (14 lines × 2) (embabel-agent-autoconfigure/models/embabel-agent-minimax-autoconfigure/src/main/kotlin/com/embabel/agent/config/models/minimax/MiniMaxModelsConfig.kt)
- Duplicated block (14 lines × 4) (embabel-agent-api/src/main/kotlin/com/embabel/agent/spi/support/ToolLoopLlmOperations.kt)
- …and 141 more
Changes since last survey
- 29 commits — 21 feature/other, 8 fixes
By area
- embabel-agent-autoconfigure/models — 9 commits
- embabel-agent-api/src — 7 commits
- embabel-agent-a2a/src — 5 commits
- embabel-agent-openai/src — 4 commits
- (root) — 1 commit
- embabel-agent-autoconfigure/embabel-agent-shell-autoconfigure — 1 commit
- embabel-agent-common/embabel-agent-ai — 1 commit
- embabel-agent-rag/embabel-agent-rag-core — 1 commit
Notable commits
- fix: Fix A2A tasks/resubscribe routing and replay (#2230)
- fix: Fix A2A thread safety and implement tasks/get, tasks/cancel (#2155)
- fix: Fix Responses API custom header forwarding (#2147)
- fix: Fix UnfoldingTool discovery for CGLIB proxies (#2152)
- fix: Fix shell not exiting on quit/exit with Spring Shell 4 (#2201)
- fix: Fix/tool response adapter bracket text (#2197)
- fix: Fix: serve the A2A agent card at agent-card.json, as A2A 0.3 requires (#2143)
- fix: Revert "Fix A2A tasks/resubscribe routing and replay" (#2240)
- change: #1550: Confirmation Guarded Tool (#2094)
- change: A BYOK key builds GPT-6 and other catalog models the way the catalog declares them (#2203)
- change: A model served over the Responses API sees the images and documents it is sent (#2202)
- change: A2A client with OTel contextId propagation and server observability (#2038)
- change: Add PowerTokensCatalogIT (OpenAI-compatible smoke, #2066) (#2170)
- change: Count Anthropic prompt-cache tokens in usage, cost and budgets (#2209)
- change: Count the blank lines between leaves when checking if a section fits in one chunk (#2179)
- change: Declare url and scm on modules rejected by Maven Central (#2199)
- change: One reasoning effort on LlmOptions reaches OpenAI and Claude (#2235)
- change: Prepare 1.5.4 Release (#2198)
- change: Refactor: tools() is the single override point and returns bare names (#2195)
- change: Share decision model catalog registration (#2167)
- …and 9 more
Architecture
- Unchanged — 0 containers · 22 contexts · 28 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 68af0de7f671b4ae8bddbca6a43927bbe88e3652 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.