# Programming Languages and Frameworks Used in Embabel Agent: Complete Technical Breakdown

> Explore the programming languages and frameworks powering Embabel Agent. Discover Java, Kotlin, Spring Boot, and Spring AI integration in this technical deep dive.

- Repository: [Embabel/embabel-agent](https://github.com/embabel/embabel-agent)
- Tags: technical-breakdown
- Published: 2026-08-14

---

**Embabel Agent is primarily built with Java and Kotlin, running on a Spring Boot foundation with Spring AI integration for LLM connectivity.**

The embabel-agent repository from Embabel is a polyglot AI agent platform that combines enterprise-grade Java infrastructure with modern Kotlin DSLs. This article examines the specific programming languages, frameworks, and libraries that power this open-source agent framework.

## Programming Languages: Java and Kotlin

Embabel Agent uses **both Java and Kotlin** strategically across its codebase.

**Java** handles core libraries, servlet APIs, and large-scale components where stability and ecosystem compatibility matter most. You'll find Java in the observability module (`embabel-agent-observability`), where [`TrackedAspect.java`](https://github.com/embabel/embabel-agent/blob/main/TrackedAspect.java) implements Micrometer-based tracing through AOP.

**Kotlin** dominates the DSL-style skill definitions, concise service code, and modern language features. The [`SkillScript.kt`](https://github.com/embabel/embabel-agent/blob/main/SkillScript.kt) file in `embabel-agent-skills/src/main/kotlin/com/embabel/agent/skills/script/` demonstrates this pattern—it parses and executes user-defined skills with Kotlin's expressive syntax.

This dual-language approach lets the project leverage Java's mature ecosystem while benefiting from Kotlin's null safety, coroutines, and type-safe builders.

## Core Framework: Spring Boot

The entire architecture rests on **Spring Boot**. According to the [`pom.xml`](https://github.com/embabel/embabel-agent/blob/main/pom.xml) in the repository root, the project declares standard Spring Boot starters for web, actuator, and testcontainers support.

Spring Boot provides:

- **Dependency injection** across all modules
- **REST endpoint** infrastructure for agent interactions
- **Embedded servlet container** (Netty-based, via Spring WebFlux)
- **Auto-configuration** for the AI model bindings

The [`StarwarsPromptProvider.kt`](https://github.com/embabel/embabel-agent/blob/main/StarwarsPromptProvider.kt) in `embabel-agent-shell/src/main/kotlin/com/embabel/agent/shell/personality/starwars/` shows typical Spring component wiring with `@Component` annotations and constructor injection.

## AI Integration Layer: Spring AI and Native SDKs

**Spring AI** forms the abstraction layer for LLM interactions. The framework supports multiple providers through dedicated modules:

- **OpenAI** (`embabel-agent-openai` module)
- **Anthropic**
- **Ollama** (local models)
- **Minimax**

Beneath Spring AI, Embabel Agent pulls in native SDKs directly. The [`pom.xml`](https://github.com/embabel/embabel-agent/blob/main/pom.xml) manages versions for the **OpenAI-Java SDK**, **Anthropic SDK**, and **ONNX Runtime** for local embedding models. The [`OpenAiCompatibleModelFactory.kt`](https://github.com/embabel/embabel-agent/blob/main/OpenAiCompatibleModelFactory.kt) file shows how these SDKs integrate with Spring AI's model factory pattern.

```kotlin
// Building an agent with Spring AI + OpenAI
val agent = AgentBuilder()
    .withModel(
        OpenAiOptions.builder()
            .model("gpt-4o-mini")
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .build()
    )
    .build()

```

## Networking: Netty

The project imports the **Netty BOM** (Bill of Materials) in the parent [`pom.xml`](https://github.com/embabel/embabel-agent/blob/main/pom.xml) at lines 21-22. Netty supplies the non-blocking I/O stack that underpins both the embedded HTTP server and any client utilities for external API calls.

This choice aligns with Spring WebFlux's reactive programming model, though the codebase also supports traditional servlet-based deployment through configuration.

## Observability Stack: Micrometer and OpenTelemetry

The `embabel-agent-observability` module implements production-ready telemetry through **Micrometer** for metrics and **OpenTelemetry** for distributed tracing.

The [`TrackedAspect.java`](https://github.com/embabel/embabel-agent/blob/main/TrackedAspect.java) file demonstrates this integration:

```java
@Service
public class TrackedService {

    @Tracked
    public String process(String input) {
        // Business logic with automatic trace/span creation
        return "Processed: " + input;
    }
}

```

The `@Tracked` annotation triggers aspect-oriented programming (AOP) interceptors that inject Micrometer timers and OpenTelemetry spans without polluting business logic.

## Build and Test Infrastructure

**Maven** serves as the build system, with a multi-module structure defined in the parent [`pom.xml`](https://github.com/embabel/embabel-agent/blob/main/pom.xml). Key testing dependencies include:

- **JUnit 5** for unit and integration tests
- **SpringMockK** for Kotlin-friendly mocking in Spring contexts
- **Testcontainers** for integration testing with real infrastructure

The [`EmbabelMockitoIntegrationTest.kt`](https://github.com/embabel/embabel-agent/blob/main/EmbabelMockitoIntegrationTest.kt) in `embabel-agent-test-support` provides a reusable test harness that other modules extend.

## Internal Platform: Embabel-Common

The project imports an internal BOM called **Embabel-Common** (lines 88-99 in [`pom.xml`](https://github.com/embabel/embabel-agent/blob/main/pom.xml)). This shared library supplies:

- Common data structures across modules
- Code-generation helpers
- Cross-cutting utilities

While not open-sourced separately, references in the build files indicate this is an internal Embabel platform dependency.

## Skill Execution Engine: Kotlin DSL with Container Support

The most distinctive architectural element is the **skill engine** in `embabel-agent-skills`. It enables user-defined capabilities through three execution modes:

1. **Kotlin DSL** scripts evaluated at runtime
2. **Docker containers** for sandboxed execution
3. **Native processes** for system integration

The [`SkillScript.kt`](https://github.com/embabel/embabel-agent/blob/main/SkillScript.kt) file implements this polyglot execution environment, while skill definitions use type-safe annotations:

```kotlin
@Skill(name = "hello")
class HelloSkill {

    @Tool(name = "greet")
    fun greet(name: String): String = "Hello, $name! 👋"
}

```

## Content Processing: Apache Tika

For retrieval-augmented generation (RAG) scenarios, the `embabel-agent-rag-tika` module integrates **Apache Tika**. The [`TikaHierarchicalContentReader.kt`](https://github.com/embabel/embabel-agent/blob/main/TikaHierarchicalContentReader.kt) demonstrates Java-Kotlin interop for document ingestion and hierarchical content parsing.

## Summary

- **Primary languages**: Java (core infrastructure) and Kotlin (DSL, services, modern features)
- **Application framework**: Spring Boot with WebFlux/reactive support
- **AI abstraction**: Spring AI with native SDK fallbacks (OpenAI, Anthropic, ONNX Runtime)
- **Networking**: Netty for non-blocking I/O
- **Observability**: Micrometer metrics + OpenTelemetry tracing
- **Build system**: Maven with JUnit 5, SpringMockK, and Testcontainers
- **Skill execution**: Kotlin-based DSL with Docker and process sandboxing
- **Document processing**: Apache Tika for RAG ingestion

## Frequently Asked Questions

### What is the main programming language in embabel-agent?

Neither language dominates exclusively. **Kotlin** appears more frequently in user-facing APIs and DSLs, while **Java** anchors the observability and core infrastructure modules. The project intentionally maintains both for ecosystem compatibility and developer ergonomics.

### Is embabel-agent a Spring Boot application?

Yes. The entire platform builds on **Spring Boot** with standard starters for web, actuator, and testing. The AI integrations follow Spring Boot's auto-configuration pattern, making agent setup declarative through `application.properties` or YAML.

### How does embabel-agent connect to LLM providers?

Through **Spring AI** abstractions backed by native SDKs. For OpenAI specifically, the `embabel-agent-openai` module contains [`OpenAiCompatibleModelFactory.kt`](https://github.com/embabel/embabel-agent/blob/main/OpenAiCompatibleModelFactory.kt), which bridges Spring AI's `ChatModel` interface with the official OpenAI-Java SDK. Similar patterns exist for Anthropic and local ONNX models.

### Can I write custom skills in languages other than Kotlin?

The skill engine primarily targets **Kotlin** for inline script definitions, but supports **any Docker container** and **any native executable** through the [`SkillScript.kt`](https://github.com/embabel/embabel-agent/blob/main/SkillScript.kt) execution framework. This lets you wrap Python tools, Node.js utilities, or compiled binaries as agent-accessible skills.