Framework
embabel/embabel-agent avatar
embabel/embabel-agent

Embabel Agent: Goal-Directed Planning for JVM Agent Flows

Agent framework for the JVM. Pronounced Em-BAY-bel /ɛmˈbeɪbəl/

4,557 stars451 forksKotlinApache-2.0

At a glance

What is it?
Embabel is a Kotlin framework for authoring agentic flows on the JVM, where a non-LLM planner assembles typed actions into plans at runtime. It fits teams already inside Spring who want their domain model to drive agent behaviour.
Who is it for?
Adopt Embabel if your agent logic lives in a JVM service alongside a real domain model and you want the sequence of steps decided at runtime rather than hardcoded. Do not adopt it if you need a language-agnostic runtime or a framework whose planning behaviour you can fully predict from a state diagram.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Kotlin, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • embabel/embabel-agent4,557 ★ · +123
Star history
Repository2026-09-102026-11-15
embabel/embabel-agent4.4k4.6k

123 Stars in the last 66 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The Problem Embabel Targets: Agent Logic That Outgrows the Flowchart

Most JVM teams reach for an LLM and end up writing a sequence: call the model, parse the output, call the next service, branch on a string. When requirements change, the branch grows. Embabel's answer is to stop writing the sequence at all. The README describes a model built from actions, goals, conditions and a domain model, with plans "dynamically formulated by the system, not the programmer." The framework then replans after each action completes, which the README compares to an OODA loop. The audience is specific: developers who already have a Spring application with typed objects and want those objects to participate in agent behaviour, rather than shipping JSON blobs between prompt calls. The README notes the framework is written in Kotlin but offers "a natural usage model from Java," and credits its origin to the creator of Spring. That origin shows in the design assumptions. Spring dependency injection, AOP decoration of functions, transaction management and persistence are treated as available infrastructure, not as things the agent framework has to reinvent.

Actions, Goals, Conditions and the Domain Model as the Planning Input

The mechanism is a search over typed building blocks. An action is a step the agent takes. A goal is what the agent is trying to achieve. Conditions are assessed before an action runs and re-evaluated after each action, which is how the system decides whether a goal has been reached. The domain model is the set of objects that inform all three. The planner is described as a non-LLM AI algorithm, and it is the component that chooses the order of actions. That distinction matters more than it first appears. The LLM is used inside actions, for prompted interactions, but it does not decide the plan. The README states that application developers usually do not deal with these concepts directly, because most conditions are inferred from data flow defined in code. In other words, you write typed methods with typed inputs and outputs, and the framework derives preconditions and postconditions from those signatures. That inference is the load-bearing part of the design. If it works for your code, you get planning almost for free. If your methods take loosely typed maps or return untyped results, the inference has little to work with, and the advantage narrows to a conventional orchestration library.

Getting a Project Started: Maven Coordinates and Spring Wiring

The README points to Maven Central for the artifact, and the badge references the coordinate com.embabel.agent:embabel-agent-api. A Maven build therefore depends on that groupId and artifactId, with the version matching a release such as 1.5.4. The documentation lives at docs.embabel.com under a versioned guide path, and the README's documentation badge points at the 1.5.0-SNAPSHOT guide, so the guide version and the artifact version are not automatically the same thing and should be checked against each other. The repository is built with Maven, as the root pom.xml indicates. Spring is the integration surface: the README says Spring can inject and manage agents and can use Spring AOP to decorate functions. That means an agent is a bean, and the actions it can take are methods the container knows about. The README names the annotations: the Spring stereotype `@Agent`, with `@Goal`, `@Condition` and `@Action` methods. Treat the versioned guide as the source for those, and confirm the API surface for the version you pin before writing code against it.

Where the Dynamic Planner Becomes the Wrong Tool

A planner that chooses its own path is harder to reason about than a state machine. The README frames this as the central differentiator, and it is, but it cuts both ways. With a finite state machine you can enumerate the reachable states and write a test for each transition. With Embabel the plan is formulated at runtime, so the set of reachable action sequences is a function of the actions you registered, the conditions the framework inferred, and the state of the domain objects at that moment. That is a large space. If your process is regulated, audited, or must produce the same steps every time for a given input, a dynamically replanned flow is a liability, not a feature. The README also notes that the planning step uses a non-LLM AI algorithm. That is a deliberate choice, and it means planning quality depends on how cleanly your actions and conditions are expressed, not on how good your model is. A vague condition will produce a vague plan, and there is no prompt to tune. The framework also assumes JVM and Spring. If your team is polyglot, or if the surrounding services are Python or Go, adopting Embabel means either a JVM boundary or a rewrite.

Embabel Against LangChain4j and Spring AI

The nearest neighbours in this space are LangChain4j and Spring AI, and the difference is where control lives. LangChain4j gives you chains: you compose steps in code, and the order is whatever you wrote. Spring AI gives you model abstraction and integration with the Spring ecosystem, plus its own approach to tool calling and advisors. Both put the developer in charge of sequencing, with the model deciding only within the boundaries you set. Embabel inverts that. You declare actions and goals, and the framework's planner decides the order, replans after each action, and can make decisions about parallelisation and other runtime behaviour, as the README puts it. The practical consequence is extensibility. The README argues that adding domain objects, actions, goals and conditions extends what the system can do "without editing FSM definitions or existing code." That is a real architectural difference, not a marketing one: in a chain-based framework, a new capability usually means a new branch or a new chain. The cost is that you cannot read the flow off the page. With LangChain4j or Spring AI, a reviewer reads the code and sees the sequence. With Embabel, the sequence is an output.

Model Mixing, Local Models and the Cost Argument

The README makes a cost and privacy argument for mixing models. Because actions are discrete typed steps, each one can be bound to a different model, and the README specifically mentions using local models for point tasks. A classification step that runs thousands of times a day can go to a small local model, while a synthesis step goes to a hosted one. This is a design that falls out of the action model rather than being bolted on: an action is a unit, and a unit can have its own model binding. The repository tree includes modules such as embabel-agent-anthropic/, embabel-agent-openai/ and embabel-agent-onnx/; check the versioned guide for how model selection is configured. The claim worth testing on your own workload is whether the planner's decisions reduce total model calls. A planner that picks a cheaper path can save money; a planner that explores more paths than a hand-written chain can cost more. That is an empirical question about your actions, and the framework's own documentation cannot answer it for you.

Testability, Licence and the Cost of Upgrades

The README states the framework is "designed for testability from the ground up," covering unit testing and agent end-to-end testing. That is a plausible claim given the typed model: if actions are methods with typed inputs and outputs, they can be called directly in a test without a model in the loop, and the planner can be exercised against known domain objects. The shape of that support is something to confirm in the guide. On licensing, the repository is Apache-2.0, which permits commercial use and modification, and the README links to the licence text. That is the extent of what can be said here; questions about patent grants, attribution in a distributed product, or compatibility with your own licence terms belong with your legal team, not with a review. On maintenance, the release history shows 1.5.2 on 2026-09-16, 1.5.3 on 2026-10-05 and 1.5.4 on 2026-10-28. That cadence means releases arrive quickly. An Apache-2.0 dependency with that release rhythm requires a pinning strategy: fix the version in your build, read the release notes before moving, and expect the documentation guide to lag or lead the artifact. The README's own documentation link points at a snapshot guide for 1.5.0, which is a reminder that the version you read about and the version you depend on may not be the same.

Editorial conclusion

Adopt Embabel if your agent logic lives in a JVM service alongside a real domain model and you want the sequence of steps decided at runtime rather than hardcoded. Do not adopt it if you need a language-agnostic runtime or a framework whose planning behaviour you can fully predict from a state diagram. Verify first that the planner produces sensible plans for your actions, that your chosen model providers are supported in the version you pin, and that Maven Central actually serves the artifact version your build resolves.

Frequently asked questions

What is embabel agent?

Embabel is a framework for authoring agentic flows on the JVM, written in Kotlin and offering a natural usage model from Java, from the creator of Spring. Flows mix LLM-prompted interactions with code and domain models, and the framework supports intelligent path finding towards goals, with the entry point published as com.embabel.agent/embabel-agent-api.

What are the key differences between Embabel and Spring AI?

The README lists Embabel's differentiators versus other agent frameworks: planning is done by a non-LLM algorithm rather than by the model, goals and actions are defined in a strongly typed domain model with no magic maps, and flows run in focused, closed or open mode through an AgentPlatform.

How do I define an agent flow in embabel?

There are two ways. An annotation-based model similar to Spring MVC uses the @Agent stereotype with @Goal, @Condition and @Action methods, and an idiomatic Kotlin DSL uses `agent {` and `action {` blocks. Both sit on a domain model of objects that can carry rich behaviour, and the planner builds the plan from those definitions.

What is the difference between focused, closed and open execution in embabel?

Focused means your code calls a method to run a particular agent with input. Closed means user intent is classified to choose among known agents, with only actions defined inside the chosen agent running. Open means the platform searches all known goals and builds a custom agent from the start state, which the documentation calls the most powerful and least deterministic mode, and which will not proceed unless it is convinced a goal applies.

Official sources

  1. embabel/embabel-agent on GitHub
  2. License: Apache-2.0
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/embabel-embabel-agent.svg)](https://hysenlabs.com/projects/embabel-embabel-agent)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/embabel-embabel-agent.svg)](https://hysenlabs.com/projects/embabel-embabel-agent)

Was this useful?