its-just-beam its-just-beam
posts research about

research

all framework paper post project talk
February 18, 2026

Agent Observability for CRM Agents: 7 Proven Hidden Checks Before Go-Live ↗

post

Agentix Labs · 2025

  • The seven checks — unified trace IDs, tool-call spans, step-level cost caps, audit trails, and escalation controls — are a rediscovery of what BEAM’s :observer, process tracing, and supervisor strategies already provide as runtime primitives
  • Prescribes immutable audit logs with field-level diffs and auth context for every agent action, which is the default behavior of a GenServer whose state transitions are logged through OTP’s built-in tracing infrastructure
  • Hard caps on tool calls with escalation fallbacks mirror OTP supervisor restart intensity limits — if a process crashes too often, the supervisor escalates rather than retrying forever
February 17, 2026

Your Agent Framework Is Just a Bad Clone of Elixir ↗

post

George Guimaraes · February 2026

  • Every pattern Python agent frameworks are building — isolated state, message passing, supervision hierarchies, fault recovery — already exists as first-class primitives in the BEAM VM, battle-tested since 1986
  • LangGraph, CrewAI, and AutoGen independently converge on actor-model patterns, evidence that this architecture is the natural shape of agent coordination, not a novel invention
  • BEAM’s preemptive scheduling and per-process garbage collection mean one misbehaving agent cannot starve or corrupt others — a property no Python runtime can offer without container-level isolation

AI Agentic Frameworks Are Building Their Own Erlang/Elixir ↗

post

George Guimaraes · February 2025

  • Traces how Python and TypeScript agent orchestrators are reimplementing message-based communication, functional composition, and immutable state propagation — the default semantics of OTP GenServers
  • Highlights supervision trees and fault tolerance as built-in BEAM capabilities that agent frameworks must construct from scratch on top of languages that lack them
  • The gap in testability and message infrastructure between agent frameworks and OTP is not incidental — it reflects the difference between a bolted-on pattern and a native runtime guarantee

Announcing Bumblebee: GPT2, Stable Diffusion, and More in Elixir ↗

post

Livebook.dev · December 2022

  • Nx.Serving runs ML inference as supervised BEAM processes, which means model serving gets the same fault tolerance, hot-code-upgrade, and per-process isolation that OTP gives to any other workload
  • Models deploy into existing Phoenix apps or Broadway pipelines without external inference servers — the BEAM is the orchestrator, not a sidecar to one
  • Distributed Nx.Serving scales inference across clustered BEAM nodes using the same primitives (message passing, process groups, supervisors) that would govern a multi-agent system, proving the runtime is ready for AI workloads

Jido: Autonomous Agent Framework for Elixir ↗

project

agentjido · December 2024

  • Agents are immutable data structures with a single cmd/2 operation — state changes are pure data transformations, making agent behavior deterministic, testable, and auditable without running processes
  • The OTP runtime layer (GenServer-based AgentServer) adds parent-child hierarchies and supervision, cleanly separating pure agent logic from lifecycle, fault recovery, and resource limits
  • Directive-based effects (spawn, schedule, emit) keep side effects as data descriptions rather than immediate actions, giving supervisors a chance to intercept, gate, or deny agent actions before they execute

MI9: An Integrated Runtime Governance Framework for Agentic AI ↗

paper

Wang, Singhal, Kelkar, Tuo · August 2025

  • Proposes FSM-based conformance engines, graduated containment (monitoring to tool restriction to isolation), and per-agent telemetry — all patterns that map directly to OTP supervision trees, process isolation, and :observer
  • The paper’s graduated containment escalation (restrict, then isolate, then kill) is exactly what an OTP supervisor already does with its restart strategies: one_for_one, rest_for_one, one_for_all
  • Validates the BEAM thesis from the other direction: AI safety researchers are independently deriving the runtime governance model that Erlang shipped in production thirty years ago

The Soul of Erlang and Elixir ↗

talk

Sasa Juric / GOTO Conferences · 2019

  • Live-demos the exact properties agents need: process isolation, preemptive scheduling, and supervision — showing a spinning computation that cannot block or crash its neighbors
  • Demonstrates shelling into a running BEAM node to inspect and manipulate processes, the kind of runtime observability that agent governance frameworks are trying to build from scratch
  • Makes “let it crash” visceral — supervisors restart failed processes automatically, which is precisely the graduated containment that multi-agent safety papers prescribe
February 16, 2026

The Zen of Erlang ↗

post

ferd.ca · February 2016

  • Explains how OTP supervision trees encode recovery strategies as explicit architectural decisions, not afterthought error handling
  • Distinguishes between errors (expected, handle inline) and failures (unexpected, let the process crash and restart clean)
  • “Let it crash” requires pre-planned supervision hierarchies — the crash is intentional, not accidental
February 15, 2026

Elixir Programming Language ↗

project

elixir-lang.org · 2012

  • Functional language built on the BEAM that adds modern ergonomics (macros, protocols, mix tooling) without sacrificing Erlang’s runtime guarantees
  • Processes are the unit of isolation and concurrency — each is a lightweight actor with its own heap, communicating only through message passing
  • The language design enforces the “let it crash” philosophy by making processes cheap and supervision trees idiomatic
February 14, 2026

Phoenix Framework ↗

framework

phoenixframework.org · 2014

  • Web framework for Elixir that exploits BEAM’s concurrency model to handle massive numbers of persistent connections (channels, LiveView)
  • LiveView eliminates the SPA/API split by rendering server-side HTML and pushing diffs over WebSockets — real-time UIs without JavaScript frameworks
  • Each request and each WebSocket connection runs in its own BEAM process, inheriting fault isolation and preemptive scheduling for free
February 13, 2026

Making Reliable Distributed Systems in the Presence of Software Errors ↗

paper

Joe Armstrong, PhD Thesis · December 2003

  • Joe Armstrong’s PhD thesis defining the principles behind Erlang/OTP: concurrency-oriented programming, process isolation, and error recovery through supervision
  • Argues that reliable systems must be built from unreliable components by isolating failures and encoding recovery strategies declaratively
  • Introduces the six rules of Erlang: isolation, everything is a process, error detection across processes, fault detection is built-in, processes can be upgraded, and failures are handled by other processes
February 12, 2026

The BEAM Book ↗

project

GitHub · 2017

  • Deep dive into BEAM virtual machine internals: schedulers, memory management, garbage collection, and the process model
  • Explains how the BEAM achieves soft real-time properties through preemptive scheduling based on reduction counts, not time slices
  • Essential reference for understanding why BEAM processes are cheap (< 1KB initial heap) and how the VM enables millions of concurrent processes
February 11, 2026

Erlang: The Movie (1990) ↗

talk

YouTube / Ericsson · 1990

  • Ericsson’s original promotional video for Erlang, demonstrating live telephony system upgrades without dropping calls
  • Shows hot code swapping in action — a running telecom switch is updated mid-call, seamlessly transferring to new modules
  • A time capsule of the problems that shaped BEAM’s design: five-nines uptime, concurrent call handling, and zero-downtime deployments