Jido: The Complete Guide to the Autonomous Agent Framework for Elixir
Jido is an autonomous agent framework for Elixir — built on OTP with immutable agent architecture, directive-based effects, composable plugins, FSM execution strategies, and multi-agent orchestration. Pure functional design inspired by Elm/Redux. 1,500+ stars, Elixir, Apache-2.0.
What Is Jido?
OTP primitives are excellent — you can build agent systems with raw GenServer. But Jido formalizes the agent pattern: agents are immutable data structures with a single command function (cmd/2). State changes are pure data transformations; side effects are described as directives and executed by an OTP runtime.
You get: deterministic agent logic, testability without processes, and a clear path to production.
- Stars: 1,500+ ⭐
- Forks: 78
- Watchers: 23
- Language: Elixir
- License: Apache-2.0
- Website: jido.run
- Demos: agentjido.xyz
- Topics: agent, ai, elixir, functional-programming, orchestration, workflow
Quick Start
defmodule MyAgent do
use Jido.Agent,
name: "my_agent",
description: "My custom agent",
schema: [
count: [type: :integer, default: 0]
]
end
{agent, directives} = MyAgent.cmd(agent, action)
Key Features
🔒 Immutable Agent Architecture
- Pure functional agent design inspired by Elm/Redux
cmd/2as the core operation: actions in, updated agent + directives out- Schema-validated state with NimbleOptions or Zoi
- Deterministic, testable without processes
📤 Directive-Based Effects
Actions transform state; directives describe external effects — never executed inline:
| Directive | Purpose |
|---|---|
Emit | Emit an event |
Spawn | Spawn a child process |
SpawnAgent | Spawn a child agent |
StopChild | Stop a child process |
Schedule | Schedule a future action |
Stop | Stop the agent |
Protocol-based extensibility for custom directives.
⚙️ OTP Runtime Integration
- GenServer-based AgentServer for production deployment
- Parent-child agent hierarchies with lifecycle management
- Signal routing with configurable strategies
- Instance-scoped supervision for multi-tenant deployments
🧩 Composable Plugins
- Reusable capability modules that extend agents
- State isolation per plugin with automatic schema merging
- Lifecycle hooks for initialization and signal handling
🔄 Execution Strategies
- Direct execution for simple workflows
- FSM (Finite State Machine) strategy for state-driven workflows
- Extensible strategy protocol for custom execution patterns
🤖 Multi-Agent Orchestration
- Multi-agent workflows with configurable strategies
- Plan-based orchestration for complex workflows
- Extensible strategy protocol for custom patterns
The Jido Ecosystem
| Package | Purpose |
|---|---|
| jido (core) | Agent behavior, directives, runtime |
| jido_ai | AI/LLM integration |
| jido_action | Reusable action library |
| jido_signal | Event/signal system |
| req_llm | HTTP LLM client |
Jido vs Alternatives
Category: This is an autonomous agent framework for Elixir/OTP.
| Feature | Jido | LangChain (Python) | AutoGen (Python) | Ash Framework (Elixir) |
|---|---|---|---|---|
| Focus | Elixir agent framework | LLM chain orchestration | Multi-agent conversations | Resource modeling |
| Stars | 1.5K ⭐ | ~100K ⭐ | ~40K ⭐ | ~4K ⭐ |
| Language | Elixir | Python | Python | Elixir |
| Immutable Agents | ✅ Elm/Redux | ❌ | ❌ | N/A |
| Directive Effects | ✅ 6 built-in | ❌ | ❌ | N/A |
| OTP Native | ✅ GenServer | ❌ | ❌ | ✅ |
| FSM Strategy | ✅ | ❌ | ❌ | Partial |
| Composable Plugins | ✅ | ✅ (Tools) | ✅ (Skills) | ✅ (Extensions) |
| Multi-Tenant | ✅ | ❌ | ❌ | ❌ |
| Pure Functional | ✅ | ❌ | ❌ | Partial |
| Plan Orchestration | ✅ | ✅ | ✅ | ❌ |
When to choose Jido: You're building agents in Elixir/OTP and want immutable, functional, testable agent architecture with built-in multi-tenant supervision.
When to choose LangChain/AutoGen: You're in the Python ecosystem and need LLM chain orchestration or multi-agent conversations.
When to choose Ash: You need resource modeling in Elixir, not agent-specific patterns.
Conclusion
Jido brings the rigor of functional programming to AI agents — immutable state, pure transformations, directive-based effects, and OTP-native runtime. For Elixir teams building distributed, autonomous agent systems, it's the only framework purpose-built for the BEAM's concurrency model. The Elm/Redux-inspired cmd/2 contract makes agents deterministic and testable by design.