Embabel Agent
Agent framework for the JVM. Pronounced Em-BAY-bel /ɛmˈbeɪbəl/
Last verified:
What is Embabel Agent?
Embabel Agent is a framework for authoring agentic flows on the JVM that seamlessly mix LLM-prompted interactions with code and domain models. It supports intelligent path finding towards goals using Goal-Oriented Action Planning (GOAP), a non-LLM AI algorithm for sophisticated planning. The framework is written in Kotlin but offers a natural usage model from Java, and comes from the creator of Spring.
Key features include sophisticated planning beyond finite state machines, superior extensibility and reuse through dynamic planning, strong typing and object orientation with full refactoring support, platform abstraction, LLM mixing capabilities for cost-effective solutions, deep Spring and JVM integration for accessing existing enterprise functionality, and design for testability from the ground up. Agents are modeled using Actions (steps an agent takes), Goals (what an agent tries to achieve), Conditions (evaluations during planning), and a Domain Model (objects informing actions, goals, and conditions).
The framework is designed for enterprise Java developers, Spring developers, and organizations looking to add agentic AI capabilities to existing JVM applications without rewriting core systems. It supports both annotation-based modeling (using @Agent, @Action, @AchievesGoal, @Condition annotations) and idiomatic Kotlin DSL. The framework can run locally with options for higher QoS in production, supports MCP (Model Context Protocol) for tool discovery and reuse, and enables agent federation. It is ideal for businesses that want to integrate AI-driven behaviors with real enterprise systems while maintaining type safety and control.
The framework includes three Spring Boot starter types: shell starter for interactive CLI development, MCP server starter for HTTP-based agent exposure, and basic agent platform starter for flexible deployment modes. It supports multiple LLM providers including OpenAI, Anthropic, Google Gemini, Mistral AI, and DeepSeek, with capability to mix different models for different tasks. The blackboard pattern serves as shared memory for agent processes, and the framework implements an OODA loop (Observe-Orient-Decide-Act) with dynamic replanning after each action.
Embabel Agent pricing
Pricing model: Freemium
The framework is open source under Apache-2.0 license and free to use. Binary releases are published to Maven Central at no cost. There is no paid tier mentioned. Users only pay for external LLM API calls (OpenAI, Anthropic, Google Gemini, Mistral AI, DeepSeek) which are billed separately by those providers. Snapshots are available from Embabel's Maven repository (https://repo.embabel.com/artifactory/libs-snapshot) for free. The project creator tool (uvx --from git+https://github.com/embabel/project-creator.git) is free to use.
Embabel Agent pros
- Sophisticated planning using non-LLM GOAP algorithm instead of simple FSM
- Dynamic replanning after each action for adaptability
- Strong typing with full Java/Kotlin refactoring support
- Deep Spring integration for dependency injection and AOP
- Can mix multiple LLMs for cost-effectiveness and privacy
- Works with existing JVM enterprise applications without rewriting
- Type-driven automatic orchestration from method signatures
- Designed for testability with easy unit and integration testing
- Platform abstraction allows local dev and production QoS without code changes
- Supports MCP protocol for standardized tool discovery and reuse
- Open mode enables novel paths combining functionality from multiple providers
- Blackboard pattern for loose-coupled data flow between actions
- Annotation-based model similar to Spring MVC for familiar usage
- Kotlin DSL option for idiomatic Kotlin developers
- Supports local models via Ollama and Docker for privacy and cost
- Human-in-the-loop capabilities with interactive shell
- Goal-oriented action planning used successfully in gaming industry
- Easy to add new domain objects without editing existing code
- Supports agent federation with other Embabel systems and third-party frameworks
- Built-in support for consuming MCP servers
Embabel Agent cons
- Early stage project with roadmap still being developed
- Requires Java 21+ which may be a constraint for some organizations
- Needs API keys from external LLM providers (OpenAI, Anthropic, etc.)
- Docker Desktop required with MCP extension for web tools
- Snapshot versions may have stability issues compared to releases
- Steeper learning curve for developers new to agent frameworks
- Open mode is least deterministic which may concern enterprise users
- Maven Central only has releases, snapshots need separate repo config
- Limited documentation compared to mature Spring projects
- Requires both OpenAI and Anthropic keys for some examples
- Kotlin-heavy codebase (92.5%) may be challenging for pure Java teams
- No built-in GUI monitoring dashboard mentioned
- Community still growing (2.9k stars but relatively new)
- Complex setup for MCP tools configuration
- Agent behavior can be non-deterministic due to LLM calls
Frequently asked questions about Embabel Agent
What is Embabel Agent and what does it do?
Embabel Agent is a framework for authoring agentic flows on the JVM that seamlessly mix LLM-prompted interactions with code and domain models. It models agentic flows in terms of Actions, Goals, Conditions, and Domain Model, then uses Goal-Oriented Action Planning (GOAP) to dynamically formulate plans. The framework enables agents to perform tasks they weren't explicitly programmed to do by combining known steps in novel order, making decisions about parallelization and runtime behavior.
How do I get started with Embabel Agent?
You can get started by creating a project from the Java or Kotlin GitHub template by clicking 'Use this template' on GitHub, or use the project creator tool: uvx --from git+https://github.com/embabel/project-creator.git project-creator. Choose Java or Kotlin, specify project and package name, and you'll have an agent running in under a minute if you have OPENAI_API_KEY and Maven installed. You'll need Java 21+, an API key from OpenAI/Anthropic/Google, and optionally Maven 3.9+.
What LLM providers does Embabel support?
Embabel supports OpenAI (GPT-4, GPT-5), Anthropic (Claude 3.x), DeepSeek, Google Gemini (both OpenAI-compatible endpoint and native GenAI SDK), and Mistral AI. You can mix different LLMs in the same application to leverage strengths of different models for different tasks. Local models are supported via Ollama (set 'ollama' profile) and Docker (set 'docker' profile).
What is the difference between focused, closed, and open execution modes?
Focused mode: user code requests particular functionality by calling a method to run a specific agent with input - ideal for code-driven flows. Closed mode: user intent is classified to choose an agent from all known agents - dynamic agent choice but only actions within that agent run. Open mode: user intent is assessed and platform uses all resources to achieve it, finding suitable goal among all goals and building custom agent from start state - most powerful but least deterministic, can find novel paths combining functionality from multiple providers.
How does Embabel handle planning and replanning?
Planning occurs after each action execution using Goal-Oriented Action Planning (GOAP), a popular AI algorithm used in gaming. The process analyzes current state, identifies available actions based on preconditions, searches for action sequences using A* algorithm, selects optimal plan based on cost and success probability, then executes the next action and replans. This creates an OODA loop (Observe-Orient-Decide-Act) allowing agents to adapt to unexpected results, handle dynamic environments, recover from failures, and take advantage of new opportunities.
What is the blackboard pattern in Embabel?
The Blackboard serves as the shared memory system maintaining state throughout agent process execution. It stores all domain objects, intermediate results, and process state in a central repository. Objects are indexed and retrieved by type, maintain insertion order, and are immutable once added. Action inputs come from the blackboard automatically, action outputs are automatically added, and conditions are evaluated based on its contents. This enables loose coupling between actions, flexible data flow, state persistence, and debugging support.
How do I test Embabel agents?
Agents are designed for testability from the ground up. All agents are unit testable like any Spring-managed beans - construct them with mock objects and call individual action methods. The testing library facilitates testing prompts. You can construct agents with mock objects, use FakeOperationContext for testing, and verify LLM invocations including prompts and hyperparameters. Both unit testing and agent end-to-end testing are easy. Integration tests are also supported but not yet fully documented.
What MCP support does Embabel provide?
Model Context Protocol (MCP) is a standardized way of hosting and sharing tools. Embabel can both consume and publish MCP tools. The MCP server starter allows agents to be autodiscovered and registered as MCP servers available via SSE, Streamable-HTTP, or Stateless Streamable-HTTP protocols. Built-in support exists for consuming MCP servers with configuration in application.yml. Docker Desktop has embraced MCP with a catalog of over 100 verified tools from partners like Stripe, Elastic, and Neo4j.
Can I use Embabel without writing full agents?
Yes, you can add a little AI to your application without full agents. The simplest way is to inject an OperationContext or Ai helper into a Spring component and use its AI capabilities directly. The Ai interface provides access to all AI capabilities without requiring full agent setup, perfect for adding AI features incrementally. You can use ai.withDefaultLlm().generateText() for simple text generation or ai.createObject() for structured object generation with type safety.
What are the key differentiators of Embabel vs other agent frameworks?
Embabel differentiates through: (1) Sophisticated planning using non-LLM GOAP algorithm beyond FSM/sequential execution, (2) Superior extensibility - adding domain objects/actions extends capability without editing existing code, (3) Strong typing and OOP with full refactoring support, no magic maps, (4) Platform abstraction separating programming model from internals, (5) Easy LLM mixing for cost-effective solutions, (6) Deep Spring/JVM integration for enterprise functionality access, (7) Designed for testability from ground up like Spring eased testing for enterprise Java.