Welcome to the Glasscraps Table

OTP isn't just servers — it's the table itself

Every bet on this table — skill executor, tool worker, cron scheduler, memory store — is an OTP GenServer. That means every process has a parent who watches, a lifecycle you can track, and a crash that doesn't fold the whole game:

• A supervisor at the head of the table — like the pit boss who doesn't blink
• A lifecycle you can see start→run→bust→rebuy
• A state you inspect with :sys.get_state/1 — no guesswork
• A failure that doesn't take down the whole casino

When a skill executor craps out — it buys back in, doesn't stiff you. When a tool times out — the pit boss handles it, not you. OTP is the felt on the table. You can see it all through the glass.

The skill registry — every chip on the table

In most agent frameworks, "skills" are files scattered in a directory — like cash stuffed in random pockets in a Vegas hotel room at 4am. Glasscraps stacks every chip on the felt as an Ecto schema row in PostgreSQL:

• Name — reads the chip's face
• Version — semver with Version.match?/2
• Dependencies — who needs what to play
• Source — local deck, marketplace, git, HTTP
• Lifecycle — dealt→validated→played→cached→busted

The croupier is queryable. Repo.all(Skill) shows every chip in play. Repo.get_by(Skill, version: "~> 1.2") finds the exact stack you need. The skill is on the table — not in a pocket you hope you didn't lose.

LiveView — the glass in the table

Every other agent framework keeps the action behind a curtain — React app, Vue dashboard, terminal window. Glasscraps puts the game on a glass table. The same OTP application dealing the rolls also shows you every bounce:

• No REST API — the GenServers are the cards at the table
• No separate deploy — one mix phx.server and the game is live
• Real-time by default — every panel is a window into the felt

Pop open the cron board and you're watching the same GenServer that's running the bets. Open the skill registry and you're querying the same Ecto schema the dealer uses. No cache. No sync. No "results in 15 minutes." What you see is exactly what the dice show — right through the DayGlo glass.

Cron — place your bets, watch them ride

Every other framework schedules jobs like a back-alley bookie — a line in /etc/crontab, a YAML file you hope someone reads. Glasscraps puts every bet on the table as an Ecto record:

• Schedule — ISO 8601, cron expression, or "run it once and see what happens"
• Prompt — the full play the dealer calls
• Skill attachments — the chips the bet needs
• Model override — switch dealers mid-game
• Delivery — where the payout lands

Bets that crap out don't vanish into the house's pocket. They land in the dead letter queue — an Ecto table with the full error, the full output, and the original bet slip. Reroll from the browser. Edit from the browser. Walk away from the browser. No terminal required.

Memory — the house never forgets

Most agents have "memory" like a drunk at the slots — one push of "clear context" and the whole session disappears. Glasscraps runs two banks:

• Warm — in-process ETS, the chips still on the table. Fast. Hot. Volatile. Like the first hit of amyl.
• Cold — Ecto-persisted, the house vault. Survives every reset. Like the concrete under the casino floor.

Both are visible and editable through the glass. See every chip on the warm table. See what's stacked in the cold vault. Edit entries from the UI — add chips, remove chips, count the take. See exactly what the dealer will read on the next roll.

Model adapters — switch dealers at will

OpenAI dealer on one table, Anthropic dealer on another, llama.cpp in a smoke-filled back room — all different rules, all different house takes. Glasscraps runs one pit with interchangeable dealers:

• Every provider is an adapter module that speaks the same game
• The registry maps names to dealers
• Swap at runtime — no reset, no "game closed for renovations"
• Each adapter comes with its own config schema (API key, table limit, model, house edge)

The dealer roster is on the glass. See who's dealing, what their limits are, what they cost per hand. Swap from the UI. The table picks up the new dealer on the next roll — like swapping a Vincent Black Shadow for a Glasscraps mid-race.

Secrets — no cash under the mattress

.env files, ~/.bashrc exports, sticky notes on the monitor — that's how most agents store their API keys. Glasscraps uses AWS Secrets Manager with a local strongbox for the road:

• Encrypt / decrypt — from the browser, like counting the house take
• Key rotation — a mix task, not a prayer
• Audit log — who opened the vault, when, and why
• Local fallback — for when you're playing at home, in the basement, naked, with a bottle of tequila and two dozen amyls

Every secret has provenance. No more "I think the API key is under the keyboard." The vault is visible, editable, and auditable — all through the glass.

Dead letter queue — the floor's conscience

When a cron job craps out at 3am in a Las Vegas hotel room, you don't want to reconstruct what happened from a Slack log. The dead letter queue catches every failure with the exact error, the full output, and the original bet slip. Retry from the browser. Edit from the browser. Forget it ever happened. The DLQ does not forget. The DLQ is the floor's conscience.

Telemetry — you can't fix what you can't see

Every tool dispatch emits a Telemetry event. Every model response emits a Trace. Every skill execution leaves a span. Prometheus and OpenTelemetry from the start. Not a bolt-on, not an afterthought. The whole game is wired for sound right out of the gate. You can see every wire — even the ones that should scare you.