Your agent teams coordinate through JSON files, polled queues, and worktree copies. They can’t tell if teammates are alive or dead. They shred context when it gets long.
Loomkin runs on the BEAM — where agents are native processes that message in microseconds, share memory, and never lose context.
The problem
Every AI agent team you’ve used has the same failure modes. They aren’t bugs — they’re symptoms of building actors on runtimes that don’t have them.
You spawn three agents. One goes quiet. Is it thinking? Did it crash? Is it waiting for you? The system can’t tell — “idle” and “dead” look identical. So the lead burns its context window playing detective instead of building your feature.
To avoid file conflicts, each agent gets its own full copy of the repo. Isolated, right? Until one agent half-finishes a function and another agent — supposedly sandboxed — starts failing from incomplete code it shouldn’t be able to see. Now the lead is debugging the isolation model instead of your code.
Refactoring auth means touching the router, the controller, the context, and the tests. But you can’t assign two agents to router.ex — one would overwrite the other. So you serialize what should be parallel work, and a 10-minute task takes 30.
The researcher spent 30 minutes mapping your codebase — file paths, edge cases, function signatures. Then its context window filled up. All of that became “investigated auth module, found 3 issues.” You paid for a deep analysis and got a sticky note.
The lead decomposed the task before anyone looked at the code. Agent 3 discovers the plan missed a critical dependency. But it can’t update the plan — it finishes its assignment and reports back. Three agents did work that gets thrown away.
Agents work in total isolation. One writes questionable code, nobody catches it. You find out when tests fail at the end — after you’ve already paid for all the tokens. Real teams do code review. Agent teams can’t.
The difference
Every row is a situation you’ve been in. The left column is what happened. The right column is what should have happened.
| What happens when… | Current agent frameworks | Loomkin (OTP) |
|---|---|---|
| You need a new agent | Wait 20–30 seconds for a new process to spin up | <500ms — a GenServer starts in the same VM |
| An agent sends a message | Written to a JSON file, polled by the recipient seconds later | PubSub delivers in microseconds — confirmed in the sender’s process |
| An agent goes quiet | Is it thinking? Crashed? Waiting? No way to tell — “idle” and “dead” look identical | Process.alive? returns a boolean. Supervisors auto-restart crashed agents |
| Two agents need the same file | Entire repo gets copied to separate worktrees. Merging is your problem | Region-level locks — two agents edit different functions in the same file, in parallel |
| Context window fills up | Old messages get summarized into one sentence. Details are gone forever | Context Mesh — overflow goes to keeper processes. Full fidelity, queryable by any agent |
| An agent discovers the plan is wrong | Finishes its assignment anyway. Reports back. Lead re-plans from scratch | Living plans — any agent can create tasks, flag blockers, or propose revisions in real-time |
| You want agents to review each other | Not possible — agents work in isolation, no mechanism for peer feedback | Native review protocol — review gates on critical paths, real-time pair programming |
| An agent crashes mid-task | Nobody notices. The agent just stops responding. Lead might figure it out eventually | Supervisor restarts it in milliseconds. Context survives in keepers. Team gets notified |
| You want 10+ agents | 3–5 is the practical limit before coordination overhead overwhelms the work | 100+ lightweight BEAM processes — coordination is in-memory, not API calls |
Context Mesh
Other systems shred old context to make room. Loomkin offloads it to lightweight keeper processes — full fidelity, queryable by any agent, persisted to SQLite.
1,000 keepers on 500MB of RAM = 100 million tokens preserved simultaneously
By the numbers
Capabilities
27 built-in tools, a persistent decision graph, and a LiveView workspace — supervised, fault-tolerant, and hot-reloadable.
Every session is a team of one that auto-scales. Solo agent to full swarm — no mode switch, no opt-in. The agent decides based on task complexity.
Files, search, shell, Git, LSP diagnostics, decision logging — each a supervised action that can crash independently without taking down the session.
SQLite-backed DAG with 7 node types, typed edges, and confidence scores. Persists reasoning across sessions. Any agent can read and write to it.
Streaming chat, interactive decision graph, diff viewer, team dashboard — all server-rendered over WebSocket. Zero JavaScript framework.
Cheap models for grunt work, expensive models for judgment calls. Dynamic escalation: if a cheap model fails twice, auto-promote to the next tier.
Burrito-wrapped for macOS and Linux. No Erlang, no Elixir install. Download, set your API key, run.
Under the hood
A supervision tree from user input to model output, with fault isolation at every boundary. Agents, keepers, and tools are all GenServers under OTP supervisors.
Quick start
Elixir 1.18+, an API key, and six commands.