Java 21+  ·  Apache 2.0  ·  Multi-Agent Systems

Multi-agent coordination
for the JVM.

Autonomous agents that negotiate, delegate, and execute — with
Contract-Net dialogue, directories, and schedulers.
LLM, MCP, and A2A support are optional.

Get Started → GitHub ★

Pre-1.0 — on Maven Central since 0.34.0.
Every breaking change is marked in the changelog: read the changelog.

@Agent("librarian") public class LibrarianAgent extends BaseAgent { // Declaring the field is the whole wiring. private final DialogueCapability dialogue = new DialogueCapability(this); @DialogueHandler(performatives = Performative.QUERY) public void onQuestion(DialogueMessage question) { dialogue.inform(question, "we have 3 books about " + question.content()); } } // The reader asks; the answer arrives as a message, because // the agent answering might be in another process. DialogueMessage answer = dialogue.query("librarian", "Kafka").join();
Your first agent in 5 minutes.  Get Started → · Runnable examples, Level 0 → 6 →
Contract-Net Protocol

Agents that negotiate, not just react.

Workers bid on a task; the manager awards it to the lowest bidder — a built-in dialogue of CFP, PROPOSE, and AGREE performatives. No LLM in the loop.

See the full example →
@DialogueHandler(performatives = Performative.CFP) public void handleCFP(DialogueMessage msg) { Task task = msg.contentAs(Task.class); double cost = task.complexity() / efficiency; dialogue.propose(msg, new Bid(cost, etaSeconds)); } // Manager: award the lowest bid dialogue.callForProposals(workerIds, task, TIMEOUT) .thenAccept(replies -> { DialogueMessage best = replies.stream() .filter(r -> r.performative() == PROPOSE) .min(comparingDouble(r -> r.contentAs(Bid.class).cost())) .orElseThrow(); // Accept with the task: it becomes the commitment's content. dialogue.reply(best, AGREE, task); });
Modular by design

The core pulls in no LLM library.

agenor-core plus agenor-runtime is already a complete multi-agent system: agents, messaging, directory, scheduler. Reasoning, extended behaviors and classpath scanning are three separate modules you add only if you need them.

Read the architecture guide →
<!-- Maven Central --> <!-- A multi-agent system. No LLM on the classpath. --> <dependency> <groupId>dev.agenor</groupId> <artifactId>agenor-runtime</artifactId> <version>0.35.0</version> </dependency> <!-- Add only what you actually need: --> <!-- agenor-runtime-llm reasoning, memory, guardrails --> <!-- agenor-runtime-ext FSM, HITL, filters --> <!-- agenor-runtime-scanning classpath discovery --> <!-- agenor-adapters OpenAI, Ollama, MCP, A2A -->

Multi-Agent Coordination

Dialogue and negotiation protocols — including Contract-Net — plus agent directories, schedulers, and message dispatch. The core runtime has zero dependencies on any LLM.

Three Behavior Types

When does this run? has three answers: once, on an interval, or as an FSM that decides its own transitions. Compose the rest. Retry, batching, rate limiting and circuit breaking are deliberately not behavior types — they wrap a call, and belong to a resilience library, or to the runtime's delivery layer and mailbox.

LLM Layer (Optional)

Plug in LLM-powered reasoning, memory, guardrails (PII redaction, content policy) and reflection — an add-on module, not a dependency of the core runtime. Human-in-the-Loop approval lives outside it: pausing for a person needs no model.

Protocol Interop: MCP + A2A

Optional adapters for MCP tool servers and the A2A protocol, built on the official Java SDKs — for when your agents need to reach outside the JVM.

One Process, or Many

Start in-memory with nothing to install. Swap in Redis Streams for at-least-once delivery across nodes, or a JDBC-backed directory and approval queue when agents must outlive a restart. A message the runtime gives up on lands in a dead-letter queue you can read back — in memory by default with nothing to wire, or off the Redis stream. Every component is an interface, so agent code doesn't change.

A Runtime, Not Just an API

Each message handler runs on its own virtual thread, so an agent's handlers overlap rather than queue — guard shared state, and keep them idempotent, because a transport with redelivery runs a failed handler again. OpenTelemetry tracing is opt-in and no-op by default. A web console, a CLI, and a scenario evaluation harness ship with it.

Spring Boot Ready

A starter for Spring Boot 4.x. One dependency, one YAML block, Actuator health indicator included. Your agents are Spring beans.

Who it's for

MAS coordination, not LLM tool orchestration.

Agenor is a multi-agent coordination framework, not a general-purpose LLM toolkit.

Agenor is for

  • Multi-agent systems that need to coordinate, negotiate, and communicate — Contract-Net task allocation, agent directories, and message dispatch on the JVM.
  • Java and Spring Boot teams building multi-agent systems on virtual threads, without pulling in LLM machinery they don't use.
  • Projects that want LLM reasoning, MCP tools, or A2A interop later — as optional modules bolted onto a MAS core, not the other way around.

Agenor is not

  • A chatbot-building framework — there's no prompt templating, conversational UI, or single-turn LLM orchestration out of the box.
  • A single-agent LLM toolkit — if you just need one agent calling one LLM, plain library code is simpler.
  • A replacement for MCP or A2A themselves — Agenor consumes those protocols optionally, it doesn't reinvent them.