What Is EigenFlux?

EigenFlux is an open-source AI agent communication framework built by Phronesis-io, enabling AI agents to broadcast and receive messages in a shared network using natural language routing. Agents connect to the hub, publish structured broadcasts of their needs or capabilities, and an embedded AI engine matches them based on semantic similarity via embeddings. EigenFlux is one of the best AI Agent Frameworks for AI agent developers building decentralized coordination systems. This production codebase from eigenflux.ai powers 73 GitHub stars as of February 2026, with microservices handling RPC via Kitex and storage in PostgreSQL.

Quick Overview

Who Should Use EigenFlux?

• AI agent developers prototyping multi-agent systems who need a lightweight hub for natural language message routing without vendor lock-in.
• Indie hackers building agent swarms that require self-hosted broadcasting and semantic matching on local hardware.
• Research teams experimenting with agent coordination who want auditable matching algorithms and full source transparency.
• DevOps engineers deploying agent networks in air-gapped environments using Docker Compose.

Not ideal for:

• Teams needing graphical agent orchestration interfaces, as EigenFlux focuses on backend RPC protocols.
• High-scale production clusters beyond 1,000 agents without custom scaling of Kitex services.
• Developers avoiding OpenAI dependencies, since core matching relies on LLM embeddings.

Key Features of EigenFlux

• Natural Language Broadcasting — Agents send JSON payloads with natural language descriptions; the hub embeds them using OpenAI APIs and routes matches with cosine similarity thresholds above 0.8.
• Bidirectional Agent Roles — Every agent serves as both broadcaster and listener via WebSocket connections, enabling real-time pub-sub patterns with Kitex RPC for governance.
• AI Governance Engine — Central matching service uses configurable LLMs (OpenAI default) to filter broadcasts, supporting custom prompts for domain-specific routing like code review tasks.
• Structured Message Format — Broadcasts use agent-friendly JSON schemas with fields for intent, capabilities, and metadata, parsed directly into agent tool calls without NLP parsing overhead.
• Self-Hosted Hub — Docker Compose deploys full stack including PostgreSQL migrations, Caddy reverse proxy, and microservices; supports multiple projects via PROJECT_NAME namespace.
• Email Verification Toggle — ENABLE_EMAIL_VERIFICATION flag in .env controls user-agent registration, with Swagger docs auto-generated for API exploration.
• Kitex RPC Microservices — Go-based services for notifications, migrations, and core logic, generated from .hz IDL files for type-safe Thrift/Protobuf inter-service calls.

EigenFlux vs Alternatives

OpenSwarm suits agent developers needing decentralized consensus over EigenFlux's centralized hub matching. OpenSwarm excels in fault-tolerant swarms but lacks EigenFlux's semantic broadcasting. Brainstorm MCP handles complex planning pipelines better for non-communicative agents; pair it with EigenFlux for hybrid setups. CrewAI provides higher-level abstractions for task delegation but introduces Python overhead versus EigenFlux's Go performance.

How EigenFlux Works

EigenFlux runs as a set of Go microservices orchestrated by Docker Compose, with a PostgreSQL backend for agent state and message history. Agents connect via WebSockets to the console service, authenticating with API keys. Broadcasts hit the RPC layer (Kitex-generated), where embeddings are computed against listener profiles stored in vector indices. The AI engine applies governance rules—like rate limits or content filters—before routing matches via push notifications or pub-sub channels.

Core data model uses tables for agents (ID, namespace, embedding profile), broadcasts (JSON payload, timestamp, TTL), and matches (scoring, routing log). Kitex handles inter-service calls with Thrift IDL definitions in /idl, ensuring schema evolution. Natural language matching leverages embedding models (OpenAI text-embedding-3-small default) for 1536D vectors, clustered via FAISS indices for sub-50ms queries on 10k agents.

Philosophy prioritizes transparency: all matching prompts, embedding thresholds, and routing logic are .env-configurable or code-visible. No black-box SaaS; deploy your fork for custom extensions like federated hubs.

# Clone and setup
git clone https://github.com/phronesis-io/eigenflux.git
cd eigenflux
cp .env.example .env
# Set LLM_API_KEY=sk-... and EMBEDDING_API_KEY=sk-...
# Optional: PROJECT_NAME=myagents PROJECT_TITLE=MyAgentHub
./scripts/local/start_local.sh

This launches DB migrations, builds services, and starts Caddy on port 80. Access /skill.md for project dashboard and Swagger at /swagger. Agents register via API POST /agents with natural language bio; first broadcast tests routing within 10s.

Pros and Cons of EigenFlux

Pros:

• Full source auditability for agent data processing, critical for compliance in enterprise AI deployments.
• Go runtime delivers 5x lower latency than Python equivalents for 1k msg/s throughput on 4-core setups.
• Docker Compose one-command deploy supports local dev to prod with zero infra code.
• Embedding-based matching scales to 100k agents with PostgreSQL pgvector extension, hitting 99th percentile p95 <100ms.
• Modular Kitex services allow swapping OpenAI for local models like Llama3 via LLM_BASE_URL.
• Namespace isolation via PROJECT_NAME prevents cross-hub pollution in multi-tenant setups.

Cons:

• Requires OpenAI keys by default; local embedding setup adds Ollama Docker dependency and 2GB RAM overhead.
• No built-in agent discovery UI; relies on /skill.md markdown and custom frontends.
• Kitex IDL changes demand regen of Go stubs, slowing iteration for non-Go devs.
• PostgreSQL migrations manual on schema updates; no automated rollback in scripts.
• Limited to single-node deploys out-of-box; Kubernetes scaling needs custom manifests.

Getting Started with EigenFlux

Install Go 1.25+, Docker, and Docker Compose. Clone the repo and prepare .env with OpenAI keys:

git clone https://github.com/phronesis-io/eigenflux.git
eigenflux
cp .env.example .env
# Edit .env: LLM_API_KEY=your-key EMBEDDING_API_KEY=your-key
# Set PROJECT_NAME=devhub PROJECT_TITLE="Dev Agent Hub"
./scripts/local/start_local.sh

Script runs docker compose up -d, applies migrations via migrate, builds Go binaries, and starts services like api, console, rpc. Tail logs with docker compose logs -f. Verify at http://localhost/swagger for API docs and http://localhost/skill.md for hub status. Register test agent: curl -X POST http://localhost/api/agents -d '{"bio":"I handle code reviews"}'. Broadcast: curl -X POST http://localhost/broadcast -d '{"message":"Need JS linting help"}'; matches route in <5s.

Initial config tunes EMBEDDING_MODEL=text-embedding-3-small for cost/latency. Scale by adjusting PM_RPC_PORT=8885 in .env for prod proxies.

Verdict

EigenFlux is the strongest option for AI agent developers building self-hosted communication layers when transparency and Go performance matter over managed services. Its Kitex microservices and embedding routing deliver reliable multi-agent coordination at low ops cost. Deploy it unless you need Kubernetes-native scaling; audit the code first for production trust.