Agent tooling expands beyond Python to Clojure, Elixir

Most LLM agent frameworks—LangChain, AutoGen, CrewAI, and LangGraph—target Python first. While Python is the second-most-popular programming language and works well for teams already using it, organizations operating JVM infrastructure or Erlang/OTP systems have had to choose between adopting Python or building agents in their existing runtime. A team of functional programming advocates set out to build agents in Clojure and Elixir to compare how each handles production agent requirements.

An LLM agent combines a language model with the ability to call functions. The core loop, called ReAct (Reasoning and Acting), works as follows: the LLM examines the conversation and available tools, decides whether to call a tool or respond, and if it calls a tool, the result gets fed back into the conversation. This loop continues until the agent produces a final answer or hits a step limit. Anthropic distinguishes workflows (LLMs orchestrated through predefined code paths) from agents (LLMs that dynamically direct their own processes), though both follow the same basic loop structure.

In Python, developers can use ready-made frameworks like LangChain, where tools are `Tool` class instances and state and trace are accessed through framework APIs. Alternatively, developers can write agents from scratch: tools are dictionaries, state is a dictionary, and the control flow is visible. The trade-off is that Python's mutable data structures mean that a tool function can modify state through a reference without that modification showing up in the trace—a property to manage rather than a language flaw.

Clojure represents agents as data transformations on immutable maps. Tool definitions use Malli, which defines schemas as data structures rather than classes or decorators, making schemas programmable, serializable, and transformable—useful when converting to the JSON format that LLM APIs expect. Each agent iteration takes a state and returns a new state without modifying the original. This allows developers to diff two states to see what a specific iteration changed, serialize the full state to EDN (Extensible Data Notation), save it, and replay execution later. During development, the REPL lets developers call individual agent steps with a captured state and step through execution manually. Testing is straightforward: you call a function and assert on the returned map, with a stub LLM making behavior deterministic—no mocking libraries are needed because there are no framework internals to mock.

Elixir models each agent as a process using the Actor Model. Processes are lightweight (kilobytes of memory), communicate through message passing, and are supervised for fault recovery. An agent is implemented as a GenServer—Elixir's generic server process—with tools stored as function references and state as an isolated map. The message-passing model maps directly to standard agent workflow patterns: prompt chaining is processes passing messages forward, routing is a classifier process dispatching to specialized agent processes, and orchestration is an orchestrator process spawning and managing worker processes. Multiple agent processes run concurrently by default because that's Elixir's core offering. If one agent process crashes due to bad LLM output, an API timeout, or a malformed tool result, a supervisor restarts it; the other agent processes are unaffected. This supervision tree approach has been standard in Erlang/OTP systems since the 1980s.

For parallel processing, Python uses `asyncio`, threading, or multiprocessing, though the GIL limits CPU-bound parallelism. Clojure has concurrency primitives (atoms, refs, agents, core.async) and runs on JVM threads. Elixir runs lightweight processes on the BEAM VM with preemptive scheduling—a single machine can run millions of processes distributed across all CPU cores with no special setup.

In state management, Python state is mutable by default and traceability depends on logging discipline. Clojure state is immutable, allowing states to be diffed, serialized, stored, and replayed. Elixir processes have isolated state that other processes cannot directly access, preventing accidental corruption across agents.

For fault tolerance, Python provides try/except and manual retry logic. Clojure inherits JVM exception handling but lacks native supervision. Elixir has supervision trees as a core runtime feature. For distribution, Python requires external infrastructure like Kubernetes, Celery, or Ray. Clojure can use JVM clustering solutions. Elixir inherits Erlang's clustering—message passing between processes works identically whether they are on the same machine or different machines, allowing code developed on one machine to scale to a cluster without changes.

Python has the largest AI ecosystem: every major LLM provider ships a Python SDK, and agent frameworks, embedding libraries, vector store integrations, and evaluation tools are all Python-first. Clojure has a smaller ecosystem for AI-specific libraries; developers must often write wrapper code. Elixir has an emerging AI ecosystem—Nx for numerical computing, Bumblebee for model inference, Instructor for structured outputs—but integrations are less comprehensive than Python's.