Installation

KaimonSlate runs best as a Kaimon extension — that's the full experience: each notebook evaluates in its own gate worker (clean namespace, package management, a tailable log) and the AI agent can drive the notebook through the slate.* tools. A lighter standalone mode works without Kaimon for a quick look.

Either way, you drive it with the slate app — a small launcher, installed with Julia's app system, that starts (or attaches to) the notebook hub and shows a status TUI.

slate is a command you run in your terminal, not Julia code: installing the app writes an executable launcher into Julia's app bin directory (~/.julia/bin by default), which you'll want on your PATH. Step 3 below covers that.

Requirements

• Julia 1.12 or newer — the slate app uses Julia's app system.

• A browser (any modern Chromium/Firefox/Safari).

• Kaimon (recommended) — for the gate workers and the AI agent. For the agent's models: a logged-in claude CLI (Claude models) and/or a running Ollama (local models).

Recommended path

1. Install Kaimon

Install Kaimon and make sure it runs (see the Kaimon docs). Log in the claude CLI and/or start Ollama if you want the agent. This gives KaimonSlate its gate workers and the agent runtime.

2. Install the slate app

KaimonSlate is in the General registry. Install it as an app — this puts a slate launcher on your PATH. From the Pkg REPL (press ]):

pkg> app add KaimonSlate

The SDK it builds on, SlateExtensionsBase, is in General too, so writing an extension needs nothing beyond the default registry.

Note the app prefix: an installed app lives in its own environment, so a plain add KaimonSlate acts on whatever environment is active and won't install the launcher.

Upgrading from a pre-release install

Earlier instructions used app dev plus a manual instantiate of ~/.julia/dev/KaimonSlate. That still works but pins you to whatever is in that clone. To switch, run pkg> app rm KaimonSlate, add the registry, then pkg> app add KaimonSlate. The old clone can be deleted.

Upgrading

Two steps, and the second one matters:

pkg> registry update          # registries are cached; a new version isn't visible until you refresh
pkg> app up KaimonSlate       # `up` is short for `update`

slate                         # then run it once

Running slate is what tells Kaimon about the upgrade. Each version installs into its own directory (packages/KaimonSlate/<slug>, named after the version's contents), while Kaimon's extensions.json still points at the previous one — which is usually still on disk, so nothing errors and the update simply appears not to have happened. Launching slate re-points that entry at the new install; a running Kaimon reloads the extension within a few seconds, and the TUI's Version row reports what the hub is actually serving.

If a package or version "does not exist" and you believe it should, registry update first — a stale registry is the most common cause.

3. Put slate on your PATH

Julia's app system doesn't install a Julia function — it writes an executable launcher (a shell script on macOS/Linux, a slate.bat on Windows) into Julia's app bin directory, which is bin/ under your first depot:

macOS / Linux	~/.julia/bin/slate
Windows	%USERPROFILE%\.julia\bin\slate.bat

That directory is not on your PATH by default, and app add prints a reminder to add it. Do that once in your shell profile:

# ~/.zshrc, ~/.bashrc, …
export PATH="$HOME/.julia/bin:$PATH"

Then open a new terminal and check the shell resolves it:

which slate           # → /Users/you/.julia/bin/slate

Until it's on your PATH you can still run it by full path — ~/.julia/bin/slate — which is a handy way to confirm the install worked.

4. Run slate

slate is a terminal command, not a Julia function — run it at your shell prompt, not in the Julia REPL:

slate                 # start (or attach to) the hub + status TUI
slate my_analysis.jl  # also open that notebook in the browser (created if missing)

slate at the julia> prompt won't work

Typing slate in the Julia REPL raises UndefVarError: slate not defined — the REPL is looking for a Julia binding, and the app is a program on your PATH. Run it from your shell, or shell out from the REPL with ;:

julia> ;slate my_analysis.jl

To drive the hub from Julia instead, use the library API — serve_notebook("nb.jl"); see Embedding (programmatic) below.

The first time you run it with Kaimon installed, slate offers to register itself as a Kaimon extension:

Register Slate as a Kaimon extension now?  [Y]es · [n]o · [d]on't ask again

Say yes — Kaimon scans for extensions dynamically, so it's picked up without a restart. slate stays open and attaches the moment Kaimon brings the hub up. Now your agents have the slate.* tools and Kaimon serves your notebooks from its own hub — no extra process — and running slate again attaches to that hub as a live status viewer.

Consented, not automatic

Registration is a one-time prompt you approve — it replaces the old silent auto-register on package load. Nothing wires itself into Kaimon behind your back; KaimonSlate.register_extension() registers manually, and slate never overwrites a registration you removed.

5. Open the browser

slate opens your notebook automatically. Otherwise browse the hub index at http://127.0.0.1:8765 (set KAIMONSLATE_PORT to move it) — it lists open notebooks and opens more by path — or just ask the 💬 agent to open one (slate.open). See The AI Agent for the full tool surface.

Extension packages

Extensions add output types, widgets, assets and agent context to a notebook. They are ordinary Julia packages built on SlateExtensionsBase (see Writing an Extension) — you add them to a notebook's environment, not to the app.

Packages that live in General install directly. The rest are published through SlateRegistry, a registry that sits alongside General; add it once per machine:

pkg> registry add https://github.com/kahliburke/SlateRegistry
pkg> add SlatePlotly      # into the notebook's environment

Pkg searches every installed registry, so adding it changes nothing about how ordinary packages resolve — KaimonSlate and SlateExtensionsBase still come from General.

Several of those extension repositories are private, and installing one needs git credentials for GitHub. The registry records repository locations as HTTPS URLs, so an SSH key alone is not enough:

gh auth login          # choose HTTPS for the git protocol
gh auth setup-git      # writes the credential helper; a separate step, easily missed

A newly published version isn't visible until pkg> registry update.

Standalone (without Kaimon)

slate --own runs the hub in-process, without Kaimon (also the default when Kaimon isn't installed):

slate --own                 # own the hub locally, even if a Kaimon extension is registered
slate --own analysis.jl

Cells evaluate, widgets and figures work, and the Timeline records history. The AI agent is unavailable (it needs Kaimon), and notebooks evaluate in-process rather than in a per-notebook worker.

The status TUI

However you start it, slate shows a terminal dashboard:

• Server — whether the hub is up (this process owns it), attached (an external Kaimon-extension hub), or waiting for the extension to come up — plus the hub URL and whether Slate is registered with Kaimon.

• Notebooks — a live table of every open notebook: cells, running / stale / errored counts, its worker port, and URL.

• Keys — ↑↓/enter open the selected notebook, o opens the hub index, r restarts the hub you own, s starts a local hub (when waiting on the extension), q quits.

Embedding (programmatic)

To drive the hub from your own script instead of the app, the REPL API is still available — serve_notebook / start_server / stop_server — see Configuration and the API Reference.

In-process vs. gate worker

Even standalone, a notebook gets its own gate worker when it sits inside a Julia project and Kaimon's gate is available — giving it a clean namespace, a tailable log, package management, and isolation from the server. Otherwise it evaluates in-process. See Architecture.

Next steps

• Getting Started — open your first notebook and build a few cells.

• The AI Agent — hand work to the agent through the slate.* tools.

• Architecture — how the pieces fit together.