Four years ago at Workera – bye time, hello gray hairs – we picked Elixir to give us an unfair startup advantage. We needed to ship twice as fast and stay up. We chose fewer frontend–backend handoffs and a simple, consistent stack.
Elixir delivered on all fronts. It even turned into a great talent filter. Choosing a niche language was a bet, but it paid off. I’d call it a win.
What we didn’t expect was the double payout. I could tell you we planned for AI agents, but we didn’t. Sometimes you just get lucky. The primitives Elixir gives you (processes, message passing, supervision trees) turned out to be exactly what we needed to build an AI-native platform.
Why Elixir fits agents
One agent = one process. A clean mental model. Start many, run them side by side, let them talk via messages. No contortions.
Crashes are normal. APIs flake. Models time out. Supervisors restart the agent instantly. Failures stay local; the app stays up.
You can see the work. With a persistent connection to the frontend, users watch agents think in real time: no polling, no extra services. Visibility builds trust.
State without the drama. Each agent keeps its own notes. Less shared state, fewer surprises. When we need persistence, we add it deliberately.
None of this is new. It’s the actor model and supervision, the battle-tested playbook that kept phone switches running for decades. It maps neatly to modern agent workloads: mostly coordination and I/O.
The rough edges
It wasn’t all smooth sailing. We wrote our own API clients that others got off the shelf. We missed the early wave of agent frameworks, too: no LangChain equivalent, no plug-and-play voice tools. The upside: those gaps pushed us to build thin, focused adapters we fully understood. No black boxes. No surprise dependencies. Just code we can debug.
Where we are now
Today, hundreds of assessment sessions run concurrently, with multiple agents collaborating in each one. We’re not wrestling with half-baked AI frameworks or chasing the orchestration flavor of the month. We run on a runtime built for many independent, fault-tolerant actors, battle-hardened over decades.
Sometimes the best tool for tomorrow’s problem is the one that’s been quietly excellent all along.