<aside> 🎯

In May 2026, Google released google/ax, a distributed agent runtime. The README never says "Akka" or "Erlang." Yet lines 60–63 carry this sentence:

"tools, skills and agents are deployed as isolated actors, a distributed runtime with dynamically spawned isolated workers becomes a necessity."

Google does not call it the actor model — but AX's design is exactly the model Carl Hewitt defined in 1973 and Erlang popularized. No surprise. Take agent orchestration seriously and the design converges on the actor model.

(Companion piece: the Korean original of this article is also published on this workspace.)

</aside>

<aside> 🌐 한국어 원문: 에이전틱에 액터모델, 놀랍지 않다 · Sister piece (Akka.NET port): Building LLM Agents in Akka.NET — Porting Akka.io's Agent SDK to the Actor Model

</aside>

This essay traces why that convergence is not an accident. The intended reader is a global IT engineer who has heard of the actor model but quietly wonders, "Is anyone still using it?"

<aside> 📊

[Image #1 — Agentic AI standing on the actor model] Hero card visualizing Google AX's "isolated actor" metaphor.

File: 2026-05-24-agentic-actor-hero.png

</aside>

1. The actor model never disappeared — it just became invisible

<aside> 🎯

3-line summary

• The actor model was first formalized by Carl Hewitt in 1973 and popularized through Erlang.
• "It's out of fashion" does not mean it died — it means the model became so default that nobody mentions it anymore.
• Chat servers, IoT platforms, financial trading engines, game backends — the systems we touch every day already ride on it. </aside>

The actor model fits in three lines.

1. An actor is a unit of concurrency that encapsulates state and behavior.
2. Actors only talk through messages. No shared memory, no locks.
3. Each actor owns a mailbox (message queue) and processes one message at a time.

<aside> 📊

[Image #2 — Actor model fundamentals] Actors with mailboxes exchanging messages without shared memory.

File: 2026-05-24-actor-model-basics.png

</aside>

Why does this win at distributed systems? Borrowing from the Akka literature Memorizer: Akka Actor Model — Core Concepts, the answer is location transparency. Whether an actor lives in the same process or on a remote machine, the code that sends it a message is identical. The model does not "treat remote like local" — it assumes everything is remote and optimizes some calls back to local. As the Akka.NET notes put it Memorizer: Akka.NET — Distributed Actor Framework, this is the right direction and the reverse — "generalize local to remote" — is the path that is bound to fail.

One myth to put down: people said for a while that "the actor model is over." The opposite is true. Erlang/OTP has held up telecom infrastructure since 1986. Akka runs JVM-side chat and game backends at Kakao, LINE, and several Korean game studios. Microsoft has Orleans. JavaScript has Vert.x. The cloud has Elixir, Erlang's modern descendant. The model did not leave — it slipped down into infrastructure where you stop noticing it.

2. Tyler Jewell's read — agentic systems are distributed systems

<aside> 🎯

3-line summary

• MIT (2025): 95% of AI projects fail to hit their expected outcomes. S&P Global reports the abandonment rate doubled from 17% to 42%.
• Akka CEO Tyler Jewell's diagnosis: the failures are not failures of imagination — they are failures of infrastructure engineering.
• Agentic systems are distributed systems, and the same problems distributed systems solved long ago (queue saturation, node crashes, retry storms, distributed debugging, time-spanning workflows) come right back. </aside>

Tyler Jewell, Akka's CEO, wrote a 2025 piece Memorizer: Agentic AI: Why Experience Matters More Than Hype whose core point is simple. While LangChain was carrying a $1B+ valuation on under $15M ARR, the teams that actually pushed agentic systems to production were saying — quietly — "this doesn't hold up."