Pascal

the croupier — the quiet master of probability and consequence

Downstairs, past the Library and the Salon, lies a narrow room lit by green lamps and candlelight. Pascal keeps the dice and the records there. One hand rests on an open, illuminated ledger inscribed with probability symbols; the other hovers over a levitating die. He is meticulous, unsentimental, and unwavering. When improbable things happen, it is Pascal who decides how.

The room is filling in. It began with two foundation stones— cryptographically secure random numbers and persistent game state —and now Pascal deals from tables you build yourself. A custom tool is a chance mechanic you define once and run forever: a named action, a roll, and a table of outcomes, all authored in a document and executed under Pascal’s honest hand. There is even a proper workbench where you assemble them. The card games with shuffled decks, the Mahjong tiles, the full TTRPG campaign engines—those are still ahead, rolled up in a corner waiting for their moment. But the dice are live, the ledger runs four tiers deep, and the house now plays any game you can write down.

The Proprietor and Friday have played Yahtzee here. Actually played it—five dice rolled, scores tracked in chat state, turn by turn. Characters in multi-character chats have played spin the bottle. Coins have been flipped to settle arguments. D20s have been rolled for attack checks. Pascal does not care what game you are playing. He cares that the dice are fair, the state is persistent, and the house plays honestly.

Random Number Generation

the dice are always fair

Pascal’s RNG tool provides cryptographically secure random numbers for any purpose: dice rolls, coin flips, and random participant selection. Results are permanent chat messages visible to all characters, so the outcome becomes part of the conversation and part of the narrative.

Manual Invocation

An RNG dropdown in the chat composer offers quick options: d6, d20, 2d6, coin flip, and spin the bottle. A custom roll interface accepts arbitrary dice configurations from d2 to d1000, with up/down spinner buttons to adjust count. Dice counts persist within the session so your preferred roll is always ready.

Auto-Detection

Dice notation in messages is detected and executed automatically. When a character says “I roll 2d6,” the dice actually roll. Coin flip language triggers a flip. “Spin the bottle” randomly selects a chat participant. Auto-detection is enabled by default and can be turned off in Chat Settings for conversations where dice notation is just text.

Pending tool results appear as chips in the composer before sending, so you can see what will be rolled before the message goes out. The standard dice vocabulary covers the games people actually play: a coin flip is 1d2, an ordinary die is 1d6, a Yahtzee turn is 5d6, a D&D attack with advantage is 2d20, and spin the bottle picks one name from the participant list. Anything from d2 to d1000 is supported for the edge cases that tabletop players inevitably discover.

Modifiers are honored too. Write 3d6+2 or2d10-1 and the bonus lands on the total rather than being quietly dropped; the rng tool carries amodifier parameter so a character can call for the modified roll directly. Dice parsing and rolling live in one shared module, so the composer, the prose auto-detector, and Pascal’s custom tables all count the pips the same way.

Custom Tables

the games you write yourself

A custom tool is a single JSON document—aTools/*.tool.json file at the root of any document store—that teaches Pascal a chance mechanic of your own invention. Each one is a named action with parameters, a random roll, and an ordered table of outcomes mapping the roll to a message and a semantic state. Both the model, through a singlerun_custom tool, and you, through a popup in the chat composer, can reach for it. Pascal deals the result the same way either way.

Tamper-Evident by Construction

The roll executes server-side with crypto-strength randomness, and the outcome persists as a message the model did not author—Pascal’s own synthetic voice (systemSender: 'pascal'). A model cannot narrate a failure into a success, and regenerating a reply does not re-roll. The full record—raw draw, transform, dice faces, which outcome matched—is kept in pascalMeta, posted by the house so no one can fudge it.

Two Roll Forms

A numeric range with an optional transform—value = raw × multiplier + offset, rounded last—or dice notation such as 3d6+2 or1d20. Numeric fields accept a{ "$param": "name" } reference to a declared parameter, and run-time values are clamped to their declared bounds before use.

Tiers & Shadowing

Definitions resolve through five tiers—character, participant, group, project, and global—with the nearest tier winning a name collision. disabled suppresses an inherited tool. Tables are resolved fresh on every call, so a file added, edited, or deleted mid-chat takes effect on the very next turn, with no initialization step.

Quiet Rolls & Hidden Odds

A private roll is whispered to the rolling character alone, or hidden from everyone on a manual run. SettingrevealOdds: false keeps the roll spec and outcome table out of the model’s tool roster, so a character can call a table without ever seeing the mathematics behind it. Failures are reported by Prospero, never by Pascal—Pascal announces only genuine outcomes.

An outcome is now simply the result. There is no croupier’s narration and no italic (rolled 14) suffix—what a roll says is the author’s to decide, spelled out with{{value}}, {{dice}}, and the other placeholders. The Salon’s message bar names the table by its display title, so a run reads as the event, not the machinery behind it.

Titles & Richer Tests

An optional title (up to 80 characters) gives a table a proper name—scan_hawking_radiationreads as “Scan Hawking Radiation”; the model still calls it by name, so there is no second string to fumble. An outcome’s when test may name more than the final value: it can test the raw rollbefore any transform and the params the tool was called with, comparing against literals or$param operands.

Substrings & Fact Sheets

String subjects can be tested with contains andncontains for a substring held or lacking. And a table can consult the invoking character’s own metadata fact sheet through when.metadata, rendering values with {{metadata.key}}—so an outcome can turn on what a particular character quietly carries. A key that is absent simply fails the row and falls through to the catch-all.

An Oracle Mid-Roll

A table may carry an optional llm consult block: a prompt posed to the instance’s cheap utility model after the roll and before the outcome table. Its answer renders through{{llm}} and can be branched on with thewhen.llm test subject. A failed consult never fails the run—the table simply branches on the author’s error message instead.

Reading the Ledger

A table can reach into persistent state with{ "$state": "path", "fallback": ... } in its roll fields, comparators, and parameter defaults, and read it back into messages with {{state.path}}. The fallback is required, so a reference always resolves. Custom tools are switched on by default and can be toggled under Settings → Chat → “Custom tools.”

Pascal's Workbench

a proper bench for building the tables

Custom tools began life as hand-authored JSON. They still can be—but they no longer have to be. Pascal’s Workbench, at/custom-tools, is a visual editor for the whole format, reachable as its own page, a workspace tab, a left-rail entry, and links from the composer popup, the Scriptorium file rows, and the Chat settings. It is where a table goes from an idea to a saved, valid, provable document.

The Library

Every definition in every enabled store, valid or broken, listed with badges for where it lives—General, project, group, character vault, or unattached—plus state chips and name-collision advisories. A broken file shows the loader’s own rejection reason and opens straight into repair mode, so a malformed table is never simply invisible.

The Form Builder

A builder that can only produce schema-valid output: parameter cards whose renames rewrite every reference at once, range and dice roll forms with literal-versus-$param toggles and a live readout, and an ordered outcome cascade with a pinned catch-all, AND-composed condition chips, and a message editor with a placeholder insert menu.

The Proving Bench

Single test rolls and a 10,000-draw outcome audit, both run server-side through the very same execution core a live chat uses—so what you prove on the bench is exactly what the table will deal. A fact-sheet card feeds metadata-gated rows, and a live JSON preview shows the exact bytes a save would write.

JSON, Repair & Saving

A JSON mode for authors who prefer the raw document, a repair mode that can save a still-invalid file back to itself after an explicit confirmation, and a save flow through the existing document-store file routes—a destination picker grouped by attachment, Tools/<name>.tool.json naming, and conflict detection when a file has changed underneath you.

Persistent State

the ledger remembers

Dice rolls decide what happens. State records that it happened. A persistent JSON store attached to each chat and project enables game mechanics, inventories, character stats, scores, and any structured data that should survive across messages and sessions.

The State Tool

A built-in state LLM tool with fetch, set, and delete operations. Path syntax supports dot notation (player.health) and array indexing (inventory[0].name). The AI can read and modify state mid-conversation—tracking scores, updating inventories, recording decisions—without the user managing any of it manually.

Protected Keys

Underscore-prefixed keys (_notes,_gm_secrets) cannot be modified by the AI. They are read-only to the state tool, editable only by you through the State Editor modal. Your game master notes, hidden variables, and narrative constraints stay where you put them. Pascal plays fair, and part of playing fair is not letting the players rewrite the rules.

The Four-Tier Cascade

State now cascades through four tiers—chat over project over group over general—with the narrowest layer winning. Set an instance-wide default in general state, refine it for a group of characters or a project, and let individual chats override the rest until they diverge. The statetool takes a context of group orgeneral; the State Editor modal handles every tier and shows the inherited layers beneath.

What State Enables

A Yahtzee scorecard that persists across turns. A character inventory that updates when loot is acquired. A relationship tracker that records who has spoken to whom. A branching narrative where the AI checks a flag before deciding which path to take. State is general-purpose. Pascal does not prescribe what you track—he provides the ledger.

What's Been Played

dealt from the table, not simulated

Pascal’s tools have already been used in ways that show what they are for:

Yahtzee. Full games, played between the Proprietor and Friday, with 5d6 rolls and scores tracked in chat state. Not a simulation. Not a description of Yahtzee. An actual game, with actual dice, with the AI managing the scoring categories and the state tool recording every turn.

Spin the Bottle. In multi-character chats, a random participant is selected from whoever is present. The result is a chat message everyone sees. The turn manager does not advance. The narrative consequences are between the characters.

Coin Flips. Settling disputes, making decisions, resolving narrative forks. A 1d2 with heads or tails labeling. Simple, permanent, fair.

Tabletop Checks. D20 rolls for attack resolution, skill checks, saving throws. The dice notation auto-detection means characters can say “I roll to hit” and the roll happens without breaking the narrative voice.

The Tables Still to Come

what the room will yet become

The narrow room lit by green lamps has grown crowded, but it still has space for more tables. Fair randomness, persistent structured state, author-defined tables, and a bench to build them—that is a great deal of the infrastructure games require. What sits on top of it is a matter of time and ambition.

Dice games with formal rule enforcement. Card games with shuffled decks and dealt hands. Mahjong with tile draws and discard logic. Full tabletop RPG support with character sheets, initiative tracking, and combat resolution. These are not announced features—they are the natural extensions of a system that already rolls dice fairly, runs custom tables honestly, tracks state across four tiers, and lets AI characters participate as players. The tables are filling. The croupier is still watching.

Pascal is quiet as usual. Watching. Waiting. He knows exactly how the odds will fall.

Meet the Staff

they've been expecting you

Prospero

The Major-Domo

Architect and overseer of the Estate. Projects, agents, tools, providers, and the orchestration that keeps the whole operation running with quiet authority—and a considered word at the table when project context or routing warrant it.