E.D.D.I — Multi-Agent Orchestration Middleware for Conversational AI

E.D.D.I (Enhanced Dialog Driven Interface) is a production-grade, config-driven multi-agent orchestration middleware for conversational AI. It coordinates users, AI agents, and business systems through intelligent routing, persistent memory, and API orchestration — without writing code.

Built with Java 25 and Quarkus. Ships as a Red Hat-certified Docker image. Native support for MCP (Model Context Protocol), A2A (Agent-to-Agent), Slack, OpenAPI, and OAuth 2.0.

Latest version: 6.0.2 · Website · Documentation · License: Apache 2.0

📑 Table of Contents

• 🏁 Quick Start
• 💡 Why EDDI?
• 📸 See It In Action
• ✨ Features
• 🧩 Quarkus SDK
• 📖 Documentation
• 📋 Compliance & Privacy
• 🏗️ Development
  • Prerequisites
  • Quarkus Dev Mode
  • Maven Command Reference
  • Build & Docker
  • Kubernetes
• 🤝 Contributing
• 🔒 Security
• 📜 Code of Conduct

🏁 Quick Start

The fastest way to get EDDI running is the one-command installer. It sets up EDDI + your choice of database via Docker Compose, deploys the Agent Father starter agent, and walks you through creating your first AI agent.

Linux / macOS / WSL2:

curl -fsSL https://raw.githubusercontent.com/labsai/EDDI/main/install.sh | bash

Windows (PowerShell):

Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/labsai/EDDI/main/install.ps1" -OutFile "install.ps1"
Unblock-File .\install.ps1
.\install.ps1

Requires Docker. The wizard auto-generates a unique vault encryption key for secret management.

bash install.sh --defaults                 # All defaults, no prompts
bash install.sh --db=postgres --with-auth  # PostgreSQL + Keycloak
bash install.sh --full                     # Everything enabled (DB + auth + monitoring)
bash install.sh --local                    # Build Docker image from local source

./mvnw package -DskipTests    # Build the Java app
bash install.sh --local        # Build Docker image + start containers

🔄 Updating

The installer creates an eddi CLI wrapper that makes updating easy:

eddi update

This pulls the latest Docker image from the registry and restarts the containers. It works even when the same tag (e.g. latest) was re-published — Docker always checks the remote digest for changes.

eddi command not found? The CLI lives at ~/.eddi/eddi (Linux/macOS) or ~/.eddi/eddi.cmd (Windows). Either restart your terminal so the PATH takes effect, or use the full path:

# Linux / macOS
~/.eddi/eddi update

# Windows (PowerShell)
& "$HOME\.eddi\eddi.cmd" update

cd ~/.eddi
docker compose --env-file .env -f docker-compose.yml pull
docker compose --env-file .env -f docker-compose.yml up -d

🐳 Docker Compose (Manual)

If you prefer manual control over Docker Compose:

# Default (EDDI + MongoDB)
docker compose up

# PostgreSQL instead of MongoDB
EDDI_DATASTORE_TYPE=postgres docker compose -f docker-compose.yml -f docker-compose.postgres.yml up

# With Keycloak authentication
docker compose -f docker-compose.yml -f docker-compose.auth.yml up

# With Prometheus + Grafana monitoring
docker compose -f docker-compose.yml -f docker-compose.monitoring.yml up

# Full stack (all overlays)
docker compose -f docker-compose.yml -f docker-compose.auth.yml \
  -f docker-compose.monitoring.yml -f docker-compose.nats.yml up

Available compose overlays: docker-compose.auth.yml (Keycloak), docker-compose.monitoring.yml (Prometheus+Grafana), docker-compose.nats.yml (NATS JetStream), docker-compose.postgres.yml / docker-compose.postgres-only.yml, docker-compose.local.yml (build from source).

docker pull labsai/eddi    # Pull latest from Docker Hub

→ hub.docker.com/r/labsai/eddi

💡 Why EDDI?

Most multi-agent frameworks (LangGraph, CrewAI, AutoGen) are Python/Node libraries — great for prototyping, hard to govern in production. EDDI approaches from the opposite direction: a deterministic engine built to safely govern non-deterministic AI.

"The engine is strict so the AI can be creative." — Project Philosophy

📸 See It In Action

📊 Dashboard Platform overview with active agents, workflows, quick actions, and recent conversations	🤖 Agent Fleet All deployed agents at a glance with status, descriptions, and one-click chat
💬 Live Conversation Real-time conversation with visible actions, step timing, and tool calls	🗣️ Multi-Agent Debate Peer Review with phased discussion: Opinion → Critique → Revision → Synthesis
🛡️ Secrets Vault Envelope-encrypted secrets with rotation tracking, checksums, and per-agent access control	💰 Tenant Quotas Rate limits, cost budgets, and live usage monitoring per tenant

More screenshots: LLM Config, Logs, User Memory, Schedules, Agent Detail

⚡ LLM Task Configuration System prompt, model parameters, cascading, RAG, context window, and budget settings	📋 Real-Time Logs Live log stream with per-call cost tracking, token counts, warnings, and errors
🧠 Persistent User Memory Cross-session memory with categorized entries, visibility scoping, and conflict detection	⏰ Scheduled Execution Cron jobs and heartbeats with fire history, retry logic, and dead-letter tracking
🔧 Agent Detail Full agent config: environments, workflows, A2A, security, capabilities, and memory policy

✨ Features

🤖 Multi-Agent Orchestration

• 🔀 Intelligent Routing — Direct conversations to different agents based on context, rules, and intent
• 🗣️ Group Conversations — Multi-agent debates with 5 built-in discussion styles: Round Table, Peer Review, Devil's Advocate, Delphi, and Debate
• 💬 Slack Integration — Deploy agents to Slack channels and run multi-agent debates directly in threads
• 🪆 Nested Groups — Compose groups of groups for tournament brackets, red-team vs blue-team, and panel reviews
• 👥 Managed Conversations — Intent-based auto-routing with one conversation per user per intent
• 🎯 Capability Matching — Discover and route to agents by skill, confidence score, and custom attributes
• 🧙 Agent Father — Meta-agent that creates other agents through conversation (ships out of the box)

🧠 LLM Provider Support (12 Providers)

🔗 Standards & Interoperability

EDDI implements open standards — not proprietary APIs:

💭 Memory & Context Management

• 💾 Persistent User Memory — Agents remember facts, preferences, and context across conversations via structured key-value entries with visibility scoping (global, agent, group)
• 🧠 LLM Memory Tools — Built-in tools agents can call to read, write, and search their own persistent memory
• 💤 Dream Consolidation — Background memory maintenance: stale entry pruning, contradiction detection, and fact summarization (inspired by Anthropic's research on background memory consolidation)
• 🪟 Token-Aware Windowing — Intelligent context packing with model-specific tokenizer support and anchored opening steps
• 📝 Rolling Summary — Incremental LLM-powered summarization of older turns with a Conversation Recall Tool for drill-back into compressed history
• 🔧 Property Extraction — Config-driven slot-filling with longTerm / conversation / step scoping — EDDI's importance extraction mechanism
• 🛡️ Memory Policy (Commit Flags) — Strict write discipline marks failed task output as uncommitted (hidden from LLM context) and injects concise error digests for graceful degradation
• 🔄 Conversation State — Full history with undo/redo support

📚 RAG (Retrieval-Augmented Generation)

• 📦 7 Embedding Providers — OpenAI, Ollama, Azure OpenAI, Mistral, Bedrock, Cohere, Vertex AI
• 🗄️ 5 Vector Stores — pgvector, In-Memory, MongoDB Atlas, Elasticsearch, Qdrant
• 🌐 httpCall RAG — Zero-infrastructure RAG via any search API (BM25, Elasticsearch, custom)
• 📥 REST Ingestion API — Async document ingestion with status tracking

🛠️ Built-In AI Agent Tools

⏰ Scheduled Execution & Heartbeats

• 🫀 Heartbeat Triggers — Periodic agent wake-ups at configurable intervals for proactive behavior (inspired by OpenClaw's heartbeat architecture)
• ⏲️ Cron Scheduling — Standard cron expressions for timed agent execution
• 🔄 Conversation Strategies — persistent (reuse same conversation across fires) or new (fresh context each time)
• 📊 Fire Logging — Complete execution history with status, duration, cost tracking, and retry logic
• 🌙 Dream Cycles — Scheduled background memory consolidation with cost ceilings per run

📈 Smart Model Cascading

• 📉 Cost Optimization — Try cheap/fast models first, escalate to powerful models only when confidence is low
• 📊 4 Confidence Strategies — Structured output, heuristic, judge model, or none
• 💰 Per-Conversation Budgets — Automatic cost tracking with budget caps and eviction
• 🏢 Tenant Cost Ceilings — Monthly cost budgets per tenant with automatic enforcement

🔐 Enterprise Security & Compliance

⚙️ Configuration-Driven Architecture

• 📄 JSON Configs, Not Code — Agent behavior defined in versioned, diffable JSON documents
• 🔧 Lifecycle Pipeline — Pluggable task pipeline: Input → Parse → Rules → API/LLM → Output
• 📦 Composable Agents — Agents assembled from reusable, version-controlled workflows and extensions
• 🧪 Behavior Rules — IF-THEN logic engine for routing, orchestration, and business logic
• 📤 Import / Export — Agents portable as ZIP files with automatic secret scrubbing on export
• 🔄 Agent Sync — Live instance-to-instance sync with structural matching, content diffing, and selective resource picking — no ZIP intermediary needed
• 📝 Prompt Snippets — Reusable, versioned system prompt building blocks available as {{snippets.safety_rules}}
• 📎 Content Type Routing — MIME-based behavior rule conditions for multimodal attachment routing

🚀 Cloud-Native & Observable

• 🐳 One-Command Install — Interactive wizard sets up EDDI + database + starter agent via Docker
• ☸️ Kubernetes / OpenShift — Kustomize overlays, Helm charts, HPA, PDB, NetworkPolicy
• 📊 Prometheus & Grafana — 50+ Micrometer metrics at /q/metrics (tools, vault, memory, scheduling, conversations). Pre-built Grafana dashboard included
• 🔭 OpenTelemetry Tracing — Per-task distributed traces via OTLP (Jaeger, Tempo, Datadog). Every pipeline task emits spans with task.id, task.type, conversation.id, and agent.id
• 🩺 Health Checks — Liveness & readiness probes at /q/health/live and /q/health/ready
• 🔄 NATS JetStream — Async event bus for distributed processing
• ⚡ Virtual Threads — Java 25 virtual threads for true OS-level concurrency (no Python GIL or Node.js event loop bottleneck)
• 🗃️ DB-Agnostic — Choose MongoDB or PostgreSQL; switch with one env var. Single Docker image for both
• 🏗️ Red Hat Certified — Container certification with automated preflight checks in CI/CD

📖 Monitoring Guide: See docs/monitoring/monitoring-guide.md for architecture overview, metrics reference, alerting rules, and a production checklist.

🖥️ Manager Dashboard & Chat UI

• 🎨 React 19 Manager — Modern admin dashboard for agent building, testing, deployment, and monitoring
• 💬 Chat Widget — Embeddable React chat UI with SSE streaming and Keycloak auth
• 🔍 Audit Trail Viewer — Timeline-based compliance and debugging UI
• 📋 Logs Panel — Live SSE log streaming + searchable history
• 🔑 Secrets Manager — Write-only vault UI with copy-reference support
• 🌍 11 Languages — English, German, Spanish, French, Portuguese, Chinese, Japanese, Korean, Arabic (RTL), Hindi, Thai

🧩 Quarkus SDK

Building a Quarkus app that talks to EDDI? Use the quarkus-eddi extension:

<dependency>
    <groupId>io.quarkiverse.eddi</groupId>
    <artifactId>quarkus-eddi</artifactId>
    <version>6.0.2</version>
</dependency>

@Inject EddiClient eddi;

String answer = eddi.chat("my-agent", "Hello!");

Features: Dev Services (auto-starts EDDI in dev mode), fluent API, SSE streaming, @EddiAgent endpoint wiring, @EddiTool MCP bridge. See the quarkus-eddi README for full docs.

📖 Documentation

📋 Compliance & Privacy

EDDI provides built-in infrastructure for regulatory compliance:

🏗️ Development

Prerequisites

Windows users: Replace ./mvnw with .\mvnw.cmd in all commands below.

Quarkus Dev Mode

Dev mode starts the application with live reload — code changes are picked up automatically without restarting:

# Linux / macOS
./mvnw compile quarkus:dev

# Windows (PowerShell)
.\mvnw.cmd compile quarkus:dev

Then open http://localhost:7070. The Quarkus Dev UI is available at http://localhost:7070/q/dev.

Dev mode also enables:

• Continuous testing — press r in the terminal to re-run tests on changes
• Dev UI — browse endpoints, CDI beans, configuration, and health checks
• Live reload — Java and resource changes apply instantly

💡 Secrets Vault: To use the secrets vault (storing API keys encrypted), set the master key before starting:

# Linux/macOS
export EDDI_VAULT_MASTER_KEY=my-dev-passphrase

# Windows (PowerShell)
$env:EDDI_VAULT_MASTER_KEY = "my-dev-passphrase"

# Or in a .env file (already in .gitignore)
echo "EDDI_VAULT_MASTER_KEY=my-dev-passphrase" > .env

Without this, the vault is disabled and secret management returns HTTP 503. Any passphrase works for local development. See Secrets Vault for production setup.

Maven Command Reference

target/site/jacoco/index.html

Build & Docker

# Build app + Docker image
./mvnw clean package '-Dquarkus.container-image.build=true'

# Build without container (for install.sh --local)
./mvnw package -DskipTests

# Generate third-party licenses (Red Hat certification)
./mvnw package -Plicense-gen -DskipTests

☸️ Kubernetes

# Quickstart (one-file deployment)
kubectl apply -f https://raw.githubusercontent.com/labsai/EDDI/main/k8s/quickstart.yaml

# Kustomize overlays
kubectl apply -k k8s/overlays/mongodb/     # MongoDB backend
kubectl apply -k k8s/overlays/postgres/    # PostgreSQL backend

# Helm
helm install eddi ./helm/eddi --namespace eddi --create-namespace

Includes overlays for auth (Keycloak), monitoring (Prometheus/Grafana), NATS messaging, Ingress, and production hardening (HPA, PDB, NetworkPolicy). See the Kubernetes Guide for details.

🤝 Contributing

We welcome contributions! Please read our Contributing Guide for details on setting up your development environment, code style, commit conventions, and the pull request process.

Every PR is automatically checked by CI (build + tests), CodeQL (security), dependency review, and AI-powered code review.

🔒 Security

EDDI ships with security-by-default for production deployments:

• Authentication enforced — AuthStartupGuard fails startup if OIDC is disabled in production without explicit opt-out
• Secrets encrypted at rest — Envelope encryption (PBKDF2 → AES-256-GCM) with per-deployment salt. Never plaintext in DB
• SSRF protection — All LLM tool HTTP calls go through SafeHttpClient with private IP blocking, redirect validation, and scheme enforcement
• Security headers — X-Content-Type-Options, X-Frame-Options, Content-Security-Policy configured out of the box
• CI/CD security gates — Every push/PR is scanned by:
  • CodeQL — Semantic SAST analysis with security-extended queries
  • Trivy — CVE scanning for both filesystem dependencies and Docker images (blocking on CRITICAL/HIGH)
  • Gitleaks — Git history scanning to prevent secret/credential leakage
  • ZAP — DAST API scanning against the live Docker image (report-only)
  • CycloneDX — SBOM generation for supply chain transparency
  • Jazzer — Coverage-guided fuzz testing for security-critical parsers (PathNavigator, MatchingUtilities)
  • All actions SHA-pinned to prevent supply-chain attacks

For vulnerability reports, see our Security Policy. For architecture details, see Security Architecture.

📜 Code of Conduct

This project follows the Contributor Covenant Code of Conduct.