Embabel Puts a Spring in Your Agents Step

“Anybody who's a computer scientist should not be retired.” — Sergey Brin

We are seeing many successful engineers get a renewed excitement around AI and what innovation with the new and growing capabilities can do for society.

One such person has popped up with an exciting new open source agent framework.

I’m talking about the newly released Embabel:

Framework for authoring agentic flows on the JVM that seamlessly mix LLM-prompted interactions with code and domain models. Supports intelligent path finding towards goals. Written in Kotlin but offers a natural usage model from Java. From the creator of Spring.

Rod Johnson has created a lot of great products in his career, but is probably best known for Spring, something that was counter-culture at the time. The Enterprise Java industrial complex was pushing complex app servers that had you creating Enterprise Java Beans. Rod was solving his own complex problems in the finance world, but thought there was a better way. This ended up being the birth of the Spring framework which dramatically simplified the developer experience of Java.

He’s up for it again, this time in the world of agentic frameworks. Once again he is trying to build something that hides away a lot of the complexity, so the developer is able to focus on declaring their intent.

Let’s take a look at an agent that works on code, the https://github.com/embabel/embabel-coding-agent.

You can see how simple it is… there are as many lines of comments as imports as the simple Kotlin code that annotates the @Agent , and @AchievesGoal .

package com.embabel.coding.agent

import com.embabel.agent.api.annotation.AchievesGoal
import com.embabel.agent.api.annotation.Action
import com.embabel.agent.api.annotation.Agent
import com.embabel.agent.api.annotation.using
import com.embabel.agent.api.common.create
import com.embabel.agent.core.CoreToolGroups
import com.embabel.agent.core.ToolGroup
import com.embabel.agent.domain.library.HasContent
import com.embabel.agent.domain.library.InternetResource
import com.embabel.agent.domain.library.InternetResources
import com.embabel.agent.domain.io.UserInput
import com.embabel.coding.domain.SoftwareProject
import org.springframework.context.annotation.Profile

data class CodeExplanation(
    val text: String,
    override val links: List<InternetResource>,
) : HasContent, InternetResources {
    override val content: String
        get() = TODO("Not yet implemented")
}


@Agent(
    description = "Explain code in a software project or directory structure",
    scan = false,
)
@Profile("!test")
class CodeExplainer(
    private val coderProperties: CoderProperties,
) {

    @Action
    @AchievesGoal(description = "Code has been explained to the user")
    fun explainCode(
        userInput: UserInput,
        project: SoftwareProject,
    ): CodeExplanation = using(
        llm = coderProperties.primaryCodingLlm,
        promptContributors = listOf(project)
    ).create(
        """
                Execute the following user request to explain something about the given project.
                Use the file tools to read code and directories.
                Use the project information to help you understand the code.
                List any resources from the internet that will help the user
                understand any complex concepts and provide useful background reading.
                For example, provide links for a potentially unfamiliar algorithm.

                User request:
                "${userInput.content}"
            }
            """.trimIndent(),
    )

}

The concepts underpinning Embabel are explained as:

• Actions: Steps an agent takes

• Goals: What an agent is trying to achieve

• Conditions: Conditions to assess before executing an action or determining that a goal has been achieved. Conditions are reassessed after each action is executed.

• Domain model: Objects underpinning the flow and informing Actions, Goals and Conditions.

• Plan: A sequence of actions to achieve a goal. Plans are dynamically formulated by the system, not the programmer. The system replans after the completion of each action, allowing it to adapt to new information as well as observe the effects of the previous action. This is effectively an OODA loop.

By default, when you launch an agent, you can see how it kicks into https://medium.com/@vedantchaudhari/goal-oriented-action-planning-34035ed40d0b.

For example, after you setup the repo locally, you can run an interactive shell that lives in the embabel-agent-api subdirectory and execute prompts and see which agents will fulfill them.

Here I asked: execute "Do some deep research on how Geordies from Newcastle compare to Mackems from Sunderland" and a research agent appeared to find an answer with sources:

The JVM

We see new Python agent frameworks on the daily, and JavaScript is close behind… but having one that uses the power of the JVM is interesting too. Kotlin is a great modern language, and the JVM gives you access to the immense ecosystem that it has created over a long time. Rod sees this going to other ecosystems too… but having a strong JVM based framework is great to see.

This is just the beginning for the project, but it’s already a great starting point, and it’s already picking up community and steam!

Make sure to read Rod’s own words on why Embabel, and where it’s all going.