# Jido: an autonomous agent framework for Elixir built on OTP

> Jido formalizes multi-agent patterns in Elixir with immutable agents, actions, signals and directives. It is a good fit for teams already running OTP; it is the wrong tool if you want a Python-style LLM loop out of the box.

**agentjido/jido** — 🤖 Autonomous agent framework for Elixir. Built for distributed, autonomous behavior and dynamic workflows.

- Repository: https://github.com/agentjido/jido
- Website: https://jido.run
- Stars: 1,869 · Forks: 120
- Language: Elixir
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/agentjido-jido

## What Jido solves, and who it is written for

Jido targets a specific gap: Elixir developers who are already comfortable with GenServer, Supervisor and the rest of OTP, but who end up rebuilding the same scaffolding once several agents have to cooperate. The README lists exactly what gets reinvented: ad-hoc message shapes per GenServer, business logic mixed into callbacks, implicit effects scattered through code, custom child tracking per server, and process exit standing in for completion.

The framework formalizes each of those. Signals become a standard envelope, actions become a reusable command pattern, directives become typed effect descriptions, and parent-child hierarchy becomes a built-in concept. The README is direct about the relationship to OTP: Jido is not a better GenServer, it is a formalized agent pattern built on GenServer. That framing matters when you decide whether to adopt it. You are not replacing your runtime, you are adding a vocabulary on top of it.

The intended user is a team shipping long-running software where an agent inspects context, chooses among several steps, coordinates with other agents, and has to keep running. The README's own example of that is a stateful agent with a schema and a single command function.

## How the agent loop actually works: cmd/2, actions and directives

The core operation is `cmd/2`. An agent is an immutable data structure, and calling `cmd/2` with an action returns a tuple of the updated agent and a list of directives. State changes are explicit data transformations rather than mutations hidden inside a callback.

The README draws a line it calls the purity boundary. Agent decision logic stays explicit. Actions do the work and may be pure or effectful. Directives are reserved for effects the runtime should own. The practical rule the README gives is: if an action needs a result back immediately to continue reasoning or update state, it may perform that work itself; if the workflow has already decided on an outbound effect and wants the runtime or integration layer to own delivery, it returns a directive instead.

Built-in directives include Emit, Spawn, SpawnAgent, StopChild, StartSensor, StopSensor, Schedule and Stop, and the directive protocol is extensible for custom ones. Execution strategies are pluggable too: direct execution for simple workflows, an FSM strategy for state-driven ones, and a strategy protocol for custom patterns. Plugins extend agents with reusable capability modules, each with isolated state and automatic schema merging. State itself is schema-validated through NimbleOptions or Zoi.

## Installing Jido and running a first agent

The README recommends the Igniter installer. Running the following adds Jido to your dependencies, creates a `MyApp.Jido` instance module, writes configuration into `config/config.exs`, and adds that module to your supervision tree.

```bash
mix igniter.install jido
```

If you want a working agent rather than just the wiring, the README gives a second form that generates an example:

```bash
mix igniter.install jido --example
```

Manual installation is also documented: add `jido` to the dependency list in `mix.exs`. The README excerpt provided here cuts off mid-snippet at that point, so check the Hex package page for the exact version constraint rather than guessing one.

Once the instance module exists, an agent is a module that uses the `Jido.Agent` behaviour and declares a name, a description and a schema. The README's own example looks like this:

```elixir
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)
```

What you should see after that call is a two-element tuple: the updated agent carrying new state, and a list of directives, which will be empty if the action performed its own work and produced no runtime-owned effects.

## Where Jido stops being the right tool

The README is explicit that AI is optional. The core package gives you the agent architecture and the runtime; model integration arrives through companion packages such as `jido_ai`. If your goal is a prompt-and-response loop against a hosted model with minimal surrounding structure, you are paying for an architecture you will not use. You would be writing schemas, actions and directives to reach a result that a thin HTTP call already gives you.

There is a second boundary. Jido assumes Elixir and OTP. The immutable agent model, the supervision integration, the instance-scoped supervision and logical partitions for multi-tenant deployments all rest on that runtime. Teams without Elixir experience should treat the framework as a language decision, not a library decision.

A third consideration is the maturity of the surrounding documentation. The README excerpt provided ends inside the manual installation section, and the repository does not document a rollback path for the generated instance module. If you install via Igniter and later want to remove Jido, the README does not describe an uninstall step. Plan for that by reading the generated files before you commit them.

## How Jido differs from LangChain-style Python frameworks

The obvious alternative for someone arriving from the AI tooling side is a Python framework such as LangChain or LangGraph. The difference is not the feature list, it is where the framework puts its weight.

LangGraph models an agent as a graph of nodes and edges, and the graph is the primary artifact. Jido models an agent as an immutable value transformed by a command function, and the process tree is the primary artifact. In Jido, coordination between agents is handled by the OTP runtime: parent-child hierarchies, signal routing with configurable strategies, and supervision. In a Python graph framework, coordination is typically expressed inside the graph definition and executed by that framework's own scheduler.

The second difference is effect handling. Jido separates the decision to act from the act itself. An action either does the work or returns a directive describing an effect for the runtime to execute. That separation is unusual outside the BEAM ecosystem, and it is what makes the state transitions auditable: you can inspect the directives an agent produced without executing them.

If your team is Python-first and your agents are mostly model calls, the Python frameworks will get you there faster. If your team is Elixir-first and your agents are long-running processes that must survive failures, Jido's fit with OTP is the more useful property.

## Maintenance, releases and licence

The repository is not archived and the last push was on 2026-09-09, which is recent. The release history shows v2.3.3 on 2026-08-10, v2.3.2 on 2026-06-09 and v2.3.1 on 2026-06-02. That cadence suggests patches arrive between minor releases, and the version numbers are still in the 2.x line, so expect the API to be stable but not frozen.

Upgrade cost is the usual Elixir story: `mix.exs` version constraints plus whatever the changelog says changed. The repository includes a CHANGELOG.md, so read that before bumping rather than relying on semantic versioning alone. Because Jido splits functionality across companion packages (`jido_action`, `jido_signal`, `jido_ai`, `req_llm`), an upgrade can require coordinating several packages at once. Check the ecosystem page for support levels before assuming all of them move together.

The licence is Apache-2.0, which permits commercial use and modification with the usual conditions around notices and patent grants. This is a factual description of the licence identifier, not legal advice; if your organisation has specific licence review requirements, route it through that process.

## Conclusion

Adopt Jido if your team already writes Elixir and OTP and you need cooperating agents with explicit state transitions, since the core package gives you the runtime without pulling in a model provider. Do not adopt it if you want a ready-made LLM agent loop in another language, because the README states AI is optional and model integration lives in the separate jido_ai package. Before committing, verify two things: that the directive set covers the effects your runtime must own, and how the parent-child agent hierarchy behaves under your supervision tree. The last push to the repository was on 2026-09-09.

## FAQ

### What is Jido and what is it used for?

Jido is an autonomous agent framework for Elixir, built for workflows and multi-agent systems. It lets you define agents, connect them to actions, signals and directives, and run them with supervision and fault tolerance from OTP.

### How do I install Jido in an Elixir project?

The README recommends the Igniter installer, which adds Jido to your dependencies, creates a MyApp.Jido instance module, writes configuration into config/config.exs, and adds that module to your supervision tree. Manual installation by adding jido to mix.exs is also documented.

### Does Jido require an LLM to work?

No. The README states that AI is optional and that the core package gives you the agent architecture and runtime. Model integration comes from companion packages such as jido_ai when you need it.

## Sources

- [agentjido/jido on GitHub](https://github.com/agentjido/jido)
- [License: Apache-2.0](https://github.com/agentjido/jido/blob/main/LICENSE)
- [Project website](https://jido.run)
- [README](https://github.com/agentjido/jido/blob/main/README.md)
- [Releases](https://github.com/agentjido/jido/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/agentjido-jido