<p align="center"> <img src="assets/loomkin-banner.jpg" alt="Loomkin — The Weaver Owl" width="600"> </p>

Loomkin

What if AI agents could form teams as fluidly as humans?

Spawn specialists in milliseconds. Share discoveries in real-time. Review each other's work. Debate approaches and vote on decisions. Heal themselves when things break. Verify their own output before moving on. Remember everything across sessions — not just what happened, but why.

Watch it all unfold from a live mission control UI. Built on Erlang/OTP.

• Decision graph — persistent reasoning memory that survives across sessions (not just chat history)
• Context mesh — overflow is offloaded to Keeper processes with staleness tracking and failure memory, never summarized away. 228K+ tokens preserved vs 128K with zero loss
• Agent teams — OTP-native, <500ms spawn, microsecond coordination. 10 cheap agents for ~$0.25 vs ~$4.50 single-Opus
• Conversation agents — any agent can spawn a brainstorm, design review, or red team exercise. Deliberation as a service
• Self-healing teams — error classification, automatic diagnosis and repair via ephemeral agents, no human intervention needed
• Verification loops — autonomous write-test-diagnose-fix cycles with upstream verifiers that check output before dependents proceed
• Workspaces — persistent layer above sessions. Teams, tasks, and progress survive tab closes and reconnects
• Kindred bundles — shareable agent persona packs. Organizations group users; the reflection agent reviews team patterns and proposes improvements
• Social platform — auth, community snippets, skill publishing. Agents author and install skills from the community or git repos
• LiveView web UI — 39 components, zero handwritten JavaScript. Mission control with agent cards, comms feed, decision graph, context library, settings, permissions dashboard
• 58 built-in tools, 16 LLM providers, 665+ models via req_llm, plus Ollama for local LLMs
• Skill system — Jido-integrated runtime skills, in-app editor, publish/install flows, git repo import, and community sharing
• Hot code reloading — update tools, providers, and prompts without restarting sessions or losing state

loomkin.dev | 328 source files, ~77K LOC, 2,700+ tests

<p align="center"> <img src="assets/loomkin-example.jpg" alt="Loomkin example session — fixing a failing test" width="700"> </p>

---

How Loomkin is Different

| | Traditional AI Assistants | Loomkin | |---|---|---| | Default experience | Single agent, teams opt-in | Teams-first: every session is a team of 1+ that auto-scales | | Memory | Conversation history, maybe embeddings | Persistent decision graph — goals, tradeoffs, rejected approaches survive across sessions | | Context | Summarized away as it grows (lossy) | Context Mesh: offloaded to Keeper processes with staleness tracking, zero loss, 228K+ tokens preserved | | Agent spawn | 20-30 seconds | <500ms (GenServer.start_link) | | Inter-agent messaging | JSON files on disk, polled | In-memory PubSub, microsecond latency, cross-team discovery | | Concurrent file edits | Overwrite risk | Region-level locking with intent broadcasting | | Task decomposition | Lead plans upfront, frozen | Living plans: agents create tasks, negotiate assignments, propose revisions, re-plan as they learn | | Peer review | None | Native protocol — review gates, pair programming, structured handoffs | | Agent concurrency | 3-5 practical limit | 100+ lightweight processes per node | | Model mixing | Single model for all agents | Per-agent selection — cheap grunts + expensive judges (18x cost savings) | | Error recovery | Crash = lost session | Self-healing: error classification, ephemeral diagnostician + fixer agents, OTP supervision | | Verification | Manual testing | Autonomous verify loops — write, test, diagnose, fix, re-test. Upstream verifiers gate dependents | | Deliberation | None | Conversation agents — spawn brainstorms, design reviews, red teams on demand | | Web UI | Terminal only, or separate web app | LiveView mission control — agent cards, comms feed, decision graph, context library, permissions. Zero JS | | Decision persistence | None | PostgreSQL DAG with 7 node types, typed edges, confidence scores, pulse reports | | Session persistence | None | Workspaces persist teams and tasks across tab closes and reconnects | | Community | None | Social platform — publish skills, share kin agents, install from community or git repos | | Self-improvement | None | Reflection agent reviews team patterns and proposes improvements via kindred bundles | | MCP | Client or server | Both — expose tools to editors AND consume external tools | | Hot reload | Restart required | Update tools, providers, prompts while agents are running |

Why Elixir and the BEAM?

---

Getting Started

Prerequisites

• Elixir 1.20+ (with Erlang/OTP 28+) — versions pinned in .mise.toml
• Docker (we recommend OrbStack on macOS — fast, lightweight Docker runtime)
• Node.js 22 — for asset compilation
• An API key for at least one LLM provider (Anthropic, OpenAI, Google, etc.)

No Docker? If you prefer system-installed Postgres, set DB_PORT=5432 (or your custom port) in your environment and skip the make db.up step.

Dev container? A shared SSH-accessible container with Tailscale, mise tooling, and Postgres is available for team development. See the devcontainer config in the repo.

Install

git clone https://github.com/bleuropa/loomkin.git
cd loomkin

# Install deps, start Postgres container, set up the database
make setup

# Start the web UI
make dev
# → http://localhost:4200

Configure

Set your LLM provider API key:

export ANTHROPIC_API_KEY="sk-ant-..."
# or
export OPENAI_API_KEY="sk-..."

Optionally create a .loomkin.toml in your project root:

[model]
default = "anthropic:claude-sonnet-4-6"
weak = "anthropic:claude-haiku-4-5"

[permissions]
auto_approve = ["file_read", "file_search", "content_search", "directory_list"]

Full configuration reference

Run

# Web UI — streaming chat, file tree, decision graph, team dashboard
mix phx.server
# → http://localhost:4200

---

Features

Intelligence

• Decision graph — persistent DAG of goals, decisions, and outcomes (7 node types, typed edges, confidence tracking). Cascade uncertainty propagation warns downstream nodes when confidence drops. Auto-logging captures lifecycle events. Narrative generation builds timeline summaries. Pulse reports surface coverage gaps and stale decisions. Interactive SVG visualization in the web UI
• Context mesh — agents offload context to Keeper processes instead of summarizing it away. Any agent can retrieve the full conversation from any other agent's history. Semantic search across keepers via cheap LLM calls. Total context grows with the task instead of shrinking
• Keeper intelligence — keepers track access frequency, staleness, and confidence. Stale knowledge auto-archives. Failure memory keepers capture lessons from errors so agents avoid repeating mistakes
• Self-introspection — agents can examine their own decision history and failure patterns via built-in tools, learning from past work
• Token-aware context window — automatic budget allocation across system prompt, decision context, repo map, conversation history, and tool definitions with dynamic headroom accounting
• Tree-sitter repo map — symbol extraction across 7 languages (Elixir, JS/TS, Python, Ruby, Go, Rust) with ETS caching and regex fallback

Agent Teams

• OTP-native — each agent is a GenServer under a DynamicSupervisor. Spawn in <500ms, communicate via PubSub in microseconds. 100+ concurrent agents per node
• 5 built-in roles — lead, researcher, coder, reviewer, tester. Each with scoped tools and tailored system prompts. Custom roles and Kin agents configurable via .loomkin.toml or the Kin management panel
• Orchestrator mode — leads with specialists automatically restrict to coordination-only tools, delegating work instead of doing it themselves
• Structured handoffs — when agents hand off tasks, they pass structured context: actions taken, discoveries, files changed, decisions made, and open questions
• Conversation agents — any agent can spawn a freeform multi-agent conversation (brainstorm, design review, red team, user panel). A Weaver agent auto-summarizes the outcome
• Self-healing — error classification, agent suspension, and ephemeral diagnostician + fixer agents that repair failures autonomously. Per-role healing policies
• Verification loops — autonomous write → test → diagnose → fix → re-test cycles. Upstream verifiers auto-spawn on task completion to validate output before dependents proceed
• Speculative execution — agents work ahead on likely next steps. If assumptions hold, the work stands. If not, it gets discarded cleanly
• Task negotiation — agents can counter-propose task assignments, suggesting better-suited teammates or flagging concerns. Uncontested assignments auto-accept