# Key Use Cases for Embabel-Agent: Building Production-Ready LLM Agents in Java and Kotlin > Explore key use cases for Embabel-Agent, a JVM framework for building production-ready LLM agents in Java and Kotlin. Discover automatic planning, mixed code-LLM workflows, and observability. - Repository: [Embabel/embabel-agent](https://github.com/embabel/embabel-agent) - Tags: use-cases - Published: 2026-08-14 --- **Embabel-agent is a JVM-native framework for building goal-oriented, LLM-driven agents with automatic planning, mixed code-LLM workflows, and built-in observability.** The embabel-agent repository provides a **strongly-typed agentic platform** that separates goals, actions, conditions, and domain models into composable components. According to the embabel/emabel-agent source code, this architecture enables developers to build autonomous systems that can replan dynamically without modifying existing code. Below are the seven primary use cases that demonstrate why teams choose this framework for production agent development. --- ## Goal-Oriented Autonomous Agents with Automatic Planning The core use case for embabel-agent is creating **autonomous agents that pursue goals through automatic planning**. Developers annotate a class with `@Agent` and define methods with `@Goal`, `@Action`, and `@Condition`. The runtime—implemented in [`AgentPlatform.kt`](https://github.com/embabel/embabel-agent/blob/main/AgentPlatform.kt)—automatically constructs execution plans using **GOAP (Goal-Oriented Action Planning)** or **Utility AI** algorithms. After each action completes, the system evaluates whether replanning is necessary. This replanning capability is crucial for long-running agents. When an action fails or preconditions change, the `GoalChoiceApprover` interface determines the next best goal without developer intervention. ```java @Agent(description = "Find news based on a person's star sign") public class StarNewsFinder { // Actions automatically sequenced by the planner } ``` The planning layer is pluggable, as documented in the repository's [Planning section](https://github.com/embabel/emabel-agent/blob/main/README.md#planning-step-is-pluggable). --- ## Mixed LLM-Code Flows for Hybrid Intelligence Embabel-agent excels at **combining deterministic code with non-deterministic LLM calls** in single methods. The `Ai` interface provides `withLlm(...)` methods that let developers invoke models inline while also executing regular Java/Kotlin logic. This enables scenarios where you: - Extract structured data from unstructured input using an LLM - Enrich prompts with live database or API data - Chain multiple model calls with business logic between them ```java @Action public StarPerson extractStarPerson(UserInput userInput, Ai ai) { return ai.withLlm(OpenAiModels.GPT_41) .createObjectIfPossible( "Create a person from: " + userInput.getContent(), StarPerson.class); } ``` The `ToolGroup` and `@Tool` annotations provide the architectural foundation for this hybrid approach, as shown in the [Show Me The Code example](https://github.com/embabel/emabel-agent/blob/main/README.md#show-me-the-code). --- ## Dynamic Tool Integration via Model Context Protocol (MCP) Embabel-agent ships with a **built-in MCP client** for calling external tools through a standardized Server-Sent Events (SSE) interface. The `McpClient` class enables agents to invoke search engines, web fetchers, browsers, and custom tools without hardcoding integrations. Configuration in [`application.yml`](https://github.com/embabel/embabel-agent/blob/main/application.yml) activates tool groups like `ToolGroup.WEB`: ```java @Action(toolGroups = {CoreToolGroups.WEB}) public RelevantNewsStories findNewsStories(StarPerson person, Horoscope horoscope, Ai ai) { // Web search and fetch tools available automatically } ``` The `EmbabelToolLoopObservationConvention` standardizes how tool results flow back into the agent's context window, enabling multi-step tool use loops. --- ## Production Observability and Distributed Tracing Adding **`embabel-agent-starter-observability`** to your classpath automatically instruments the entire agent lifecycle. The [`TrackedAspect.java`](https://github.com/embabel/embabel-agent/blob/main/TrackedAspect.java) file implements AspectJ-based tracing that captures: - Agent initialization and goal selection - Action execution timing and outcomes - LLM call latency, token usage, and prompts - Tool invocation successes and failures Spans propagate through `EmbeddingEventListener` and `MicrometerAgentInstrumentation` for export to OpenTelemetry backends, Jaeger, or Prometheus. This addresses a critical gap in LLM systems: **debugging why an agent made a particular decision**. The tracing data reveals the exact sequence of planner choices, model responses, and tool results that led to any output. --- ## Multi-Model and Local Model Deployment Embabel-agent supports **pluggable model backends** through Spring AI integration. The framework works with: - **OpenAI** (GPT-4, GPT-4.1, GPT-4o) - **Anthropic** (Claude models) - **Ollama** (local open-source models) - **Docker** (containerized inference) - **OCI Generative AI** (Oracle Cloud) Switching models requires only a bean definition change. The `OpenAiConfiguration` and `EmbabelAgentPlatform` classes handle provider-specific formatting transparently. For air-gapped or cost-sensitive deployments, the `embabel-agent-starter-ollama` module demonstrates zero-code local model integration. --- ## Test-First Agent Development Unlike many LLM frameworks that resist unit testing, embabel-agent provides **`AgentTestSupport`** for capturing and asserting on LLM interactions. The [`EmbabelMockitoIntegrationTest.java`](https://github.com/embabel/embabel-agent/blob/main/EmbabelMockitoIntegrationTest.java) file in `embabel-agent-test-support` demonstrates how to: - Replace live models with `FakeOperationContext` implementations - Assert on exact prompt contents sent to the LLM - Verify tool group composition and parameter binding - Test replanning logic under simulated failure conditions ```java @Test void shouldExtractStarPersonFromInput() { // Given a captured LLM interaction // When the action executes // Then the prompt contains expected structure } ``` This enables **TDD for agents**: write tests specifying expected behavior, then implement actions to satisfy them. --- ## Extensible Federation and Cross-System Collaboration The embabel-agent roadmap includes **agent federation** capabilities for distributed systems. Future versions will support: - **A2A (Agent-to-Agent) protocol** for cross-service goal sharing - Goal and action registries across organizational boundaries - `A2AServer` implementations for external agent discovery The `GoalChoiceApprover` interface already provides hooks for external goal arbitration, laying groundwork for federated planning where multiple agent platforms collaborate on shared objectives. --- ## Summary Embabel-agent addresses seven critical use cases for production agent development: - **Automatic planning and replanning** through GOAP/Utility AI in `AgentPlatform` - **Hybrid LLM-code workflows** via the `Ai` interface and `@Action` annotations - **Standardized tool integration** through the built-in `McpClient` and MCP protocol - **Zero-configuration observability** with `TrackedAspect` and Micrometer integration - **Flexible model deployment** across cloud and local providers - **Testable architecture** using `AgentTestSupport` and `FakeOperationContext` - **Future-proof federation** via A2A protocol support These capabilities make embabel-agent suitable for applications ranging from simple chatbots to complex **autonomous research agents** that browse the web, synthesize findings, and produce structured outputs—all while remaining fully observable and testable. --- ## Frequently Asked Questions ### What programming languages does embabel-agent support? Embabel-agent is **JVM-native** and primarily targets **Java and Kotlin**. The core API in [`AgentPlatform.kt`](https://github.com/embabel/embabel-agent/blob/main/AgentPlatform.kt) and [`AgentDsl.kt`](https://github.com/embabel/embabel-agent/blob/main/AgentDsl.kt) provides idiomatic Kotlin DSL support (`agent { ... }` blocks) while maintaining full Java interoperability. All annotations (`@Agent`, `@Action`, `@Goal`) work identically in both languages. ### How does embabel-agent compare to LangChain or LlamaIndex? LangChain and LlamaIndex are Python-centric with optional JavaScript support. Embabel-agent is **purpose-built for JVM ecosystems** with compile-time type safety, Spring integration, and enterprise observability patterns. Its planning architecture (GOAP/Utility AI) differs from LangChain's chain-based approach, offering more explicit goal-action relationships. ### Can I use embabel-agent with existing Spring Boot applications? Yes. Embabel-agent is designed as **Spring Boot starters**. Add `embabel-agent-starter` to your dependencies, define an `@Agent`-annotated bean, and the framework auto-configures planning, LLM clients, and observability. The MCP client and tool groups integrate through standard Spring dependency injection. ### Is embabel-agent suitable for long-running autonomous agents? Yes. The `GoalChoiceApprover` interface and automatic replanning after each action make embabel-agent well-suited for **persistent agents** that execute over extended periods. The observability stack ensures you can audit decisions even when agents run for hours or days.