The Ensemble Control API adds HTTP run submission, state queries, capabilities discovery, run control, SSE streaming, and REST review decisions to the live dashboard – giving external systems a complete interface to trigger and observe agent runs without compiling Java.
The agentensemble-executor module lets you call AgentEnsemble directly in-process from Temporal, Step Functions, or any external workflow engine – no HTTP server, no second orchestration layer.
A structured exception hierarchy, partial result preservation, and explicit exit reasons give you the operational handles needed to run agent pipelines reliably.
Task-scoped memory lets agents accumulate knowledge across runs through named scopes, pluggable stores, and explicit isolation boundaries.
ToolPipeline chains multiple tools into a single compound tool that executes without LLM mediation between steps.
Input and output guardrails give you programmatic control over what enters and exits each agent task, without modifying prompts.
The operational layer for agent networks – interactive topology graphs, per-ensemble drill-down, audit trails, and the dashboard that ties discovery, capacity, and health together.
How to test agent ensembles that depend on remote capabilities – network stubs for predictable behavior, recordings for assertion, and isolation testing without real connections.
Protecting agent networks from themselves – rate limiting, priority queues with aging, operational profiles, and scheduled tasks for capacity-aware infrastructure.
When multiple agent ensembles need shared state – eventual consistency, optimistic locking, distributed locks, and choosing the right consistency model for the data.
How agent ensembles share capabilities across Kubernetes namespaces and clusters – realms, capacity advertisement, federated routing, and trust boundaries.
How agent ensembles discover each other’s capabilities at runtime – tag-based capability catalogs, dynamic wiring, and the shift from static to discovered routing.
What changes when agent networks need delivery guarantees – Kafka-backed request queues, delivery registries, and the operational realities of durable messaging.
The transport abstraction that makes ensemble networks infrastructure-agnostic – from in-process queues to Kafka without changing application code.
How to connect MCP servers to Java agents – McpToolFactory, lifecycle management, and mixing MCP tools with native Java tools.
What it takes to build reliable coding agents in Java – project detection, git worktree isolation, and composable tool backends.
Most human-in-the-loop designs treat humans as gatekeepers – the system pauses, waits for approval, times out. The harder design problem is building agent systems where humans connect and disconnect without becoming bottlenecks.
MCP gives agents tool-level interoperability – call a function, get a result. The harder problem is delegating a complex, multi-step process to another autonomous service. The contract between them turns out to be natural language.
Every multi-agent framework today models scripts – define agents, run tasks, get output, exit. The harder problem is building agent systems that run continuously, handle work as it arrives, and survive restarts.
In multi-agent pipelines, structured data flows between every task – and JSON’s syntax overhead compounds at every step. A pluggable serialization layer lets you trade format familiarity for token efficiency.
How declaring Java records as agent tool inputs replaces manual JSON parsing with automatic schema generation, deserialization, and validation.
Task reflection adds a persistent, automated feedback loop – after a task succeeds, an LLM analyzes whether the prompt instructions could be clearer, stores improvements persistently, and injects them on subsequent runs.
PhaseReview attaches a quality gate to any phase with APPROVE/RETRY/RETRY_PREDECESSOR/REJECT decisions, and injects reviewer feedback directly into retry prompts.
AgentEnsemble’s DAG executor, parallel phase runner, and callbacks work for purely deterministic Java functions – no ChatModel required.
Most agent frameworks require you to define agent personas before you can do any work. The central insight behind AgentEnsemble v2 is that the agent is usually accidental complexity – the task is the actual unit of work.
When your agent workload is “do the same thing to a list of items and combine the results,” you need MapReduce – not a loop. Here’s how to do it with typed, parallel agent ensembles in Java.
Three properties separate toy agent frameworks from real ones. Here’s how to get type safety, observability, and composability for multi-agent systems on the JVM.
Flat task lists handle sequential pipelines well, but they can’t express parallel workstreams where each workstream has its own internal task sequence and a defined convergence point. Phases fix that.
