Built for Production, Not Just Prototypes

The Elixir Autonomous Agent Framework

Create distributed, adaptive agent systems powered by Elixir's unmatched concurrency and reliability.

defmodule WeatherAgent do
  use Jido.Agent, name: "weather_agent"

  def start_link(_opts \\ []) do
    Jido.AI.Agent.start_link(
      agent: __MODULE__,
      ai: [
        model: {:openai, model: "gpt-4o-mini"},
        prompt: """
        You are an enthusiastic weather reporter.
        <%= @message %>
        """,
        tools: [
          Jido.Tools.Weather
        ]
      ]
    )
  end

  defdelegate chat_response(pid, message), to: Jido.AI.Agent
  defdelegate tool_response(pid, message), to: Jido.AI.Agent
end

iex(1)> {:ok, pid} = WeatherAgent.start_link()
{:ok, #PID<0.123.0>}

iex(2)> WeatherAgent.tool_response(pid, "What is the weather in Tokyo?")
{:ok, "The weather in Tokyo is sunny with a temperature of 20 degrees Celsius."}

Production-Ready From Day One

Small Memory Footprint

Run 10,000 agents for the cost of one container

Native Concurrency

True parallel execution with BEAM's actor model

Built-in Resilience

Automatic recovery from failures without external tools

Actions

From Thought to Execution

Actions transform agent intentions into real-world results. They provide a structured way for agents to affect your systems, interact with external services, and collaborate to solve complex problems.

Composable

Validated

Resilient

Extensible

defmodule CreateInvoice do
  use Jido.Action, name: "create_invoice"

  def run(%{customer_id: id, amount: amount}, _ctx) do
    with {:ok, invoice} <- BillingSystem.create_invoice(id, amount),
         {:ok, _} <- NotificationSystem.notify(:invoice_created, invoice) do
      {:ok, %{invoice_id: invoice.id}}
    end
  end
end

Agents

Autonomous, Scalable, Resilient

Jido Agents are lightweight, autonomous processes designed to work together in complex systems. Built on Elixir's actor model, they provide unmatched concurrency, fault tolerance, and scalability for your AI applications.

Lightweight

Self-Healing

AI-Ready

Tool-Equipped

defmodule CustomerSupportAgent do
  use Jido.Agent, name: "support_agent"

  def start_link(opts \\ []) do
    Agent.start_link(
      agent: __MODULE__,
      ai: [
        model: {:openai, model: "gpt-4o-mini"},
        prompt: "You help customers solve product issues."
      ],
      tools: [
        Jido.Tools.KnowledgeBase,
        Jido.Tools.TicketSystem
      ]
    )
  end
end

Signals

The Nervous System of Your Agent Network

Signals provide a standardized messaging system for your distributed agents, based on the CloudEvents specification. They serve as the communication backbone, allowing agents to exchange information, commands, and state changes seamlessly.

Standardized Structure

Flexible Dispatch

Rich Context

Instruction Handling

{:ok, signal} = Jido.Signal.new(%{
  type: "order.payment.processed",
  source: "/payments",
  data: %{order_id: "456"},
  jido_dispatch: [
    {:pubsub, [topic: "transactions"]},
    {:bus, [target: :audit_bus]},
    {:pid, [target: pid, async: true]}
  ]
})

Skills

Composable Agent Capabilities

Skills are modular, reusable modules that encapsulate specific agent capabilities. They provide a clean way to share functionality between agents, making it easy to build sophisticated behaviors from simple, composable building blocks.

Modular

Shareable

Configurable

Versioned

defmodule Jido.Skills.DataAnalysis do
  use Jido.Skill, name: "data_analysis"

  def mount(agents, opts \\ []) do
    Jido.Agent.register_action(agent, [analyze_trends])
  end

  def router(opts \\ []) do
    [
      {"jido.data_analysis.analyze",
        %Instruction{
          action: Jido.DataAnalysis.Actions.AnalyzeTrends,
          params: %{model: model}
        }},
    ]
  end

  def handle_signal(%{type: "data.analysis.analyze"} = signal, _skill_opts) do
    {:ok, signal}
  end

  def transform_result(signal, result, _skill_opts) do
    {:ok, result}
  end
end