The m-shell

Run excalibur with no arguments and you enter the m-shell: an interactive, conversational session and the main surface of the product. It's a thin layer over the same primitives the one-shot commands use — the event stream, the phase engine, the permission engine, Discovery — so nothing it does is hidden.

excalibur

EXCALIBURv0.1.0

Welcome back, Rafael

modelkimi-k2.7-code

orgExcaliburOSS

userrafael

▸ Tip

Just describe what you want — Excalibur routes it. Press / for commands, ↑ for history.

▸ What’s new

Time machine: rewind any run and fork from any step — only what changed re-runs.

Three ways to talk to it

How intent routing works

Natural-language input is classified and routed — "an implicit run, but intelligent," never blind:

Inline approvals

Risky operations pause for a one-keystroke decision, always respecting the standard-safe preset:

Choosing always writes an allowlist entry to .excalibur/config.yaml, so a given action is confirmed once. See Safety for what requires approval by default.

Editing input, like you'd expect

• ↑ / ↓ walk your prompt history (persisted per repo) to reuse and edit earlier prompts.
• Interrupt anytime — type while a run streams and Excalibur reads what you mean instead of blindly queuing it (see below). Esc cancels the running step.
• @file and #symbol pull fresh context straight from disk at send time.
• Multiline editing, with your $EDITOR for longer prompts.

Interrupt it — without losing the work

Talk to Excalibur while a run is streaming and it triages what you said, instead of forgetting the work in flight (the thing other agents get wrong):

A paused run is a first-class, resumable thread: /threads lists it with a ⏸ marker and the status line shows N paused. Esc always hard-cancels the current step — nothing you typed is ever silently dropped.

A live TUI you can read

One stream of events renders into a calm, legible system:

• Phase timeline — a vertical rail that fills as Plan → Implement → Verify → Document → Review → PR complete.
• Narration — between actions the agent talks to you like a pair-programmer: warm, first-person prose, streamed token-by-token, in your language.
• Thinking indicator — the agent's real current action, with a live tokens/cost ticker.
• Diffs with a gutter, inline under the active phase.
• Swarm lanes — one lane per parallel agent on larger tasks.
• Status line, always visible: autonomy · workflow · model · elapsed · cost · safety — plus ctx NN% (how full the context window is) and N paused when you've parked work.

The theme auto-adapts to your terminal (truecolor → 256 → 16 → NO_COLOR), with a nerd-font glyph set and an ASCII fallback, and degrades to plain logs over SSH/CI.

Understand-first scope

Before building something non-trivial, map the ground first — read-only. Ask "what's involved in adding X?" (or run excalibur scope "<task>") and Excalibur fans out parallel read-only explorers and returns a scope map: the relevant files and subsystems, what already exists vs. what's still missing, and the risks — no edits, nothing to approve. On a large build it runs this automatically before planning, so the plan (and plan-shaping) is grounded in your real code, not guesses.

Slash commands & your own

Every built-in command has a slash form, and any prompt_template (per-user or per-repo) becomes an invocable /command with placeholders ($1, $ARGUMENTS).

Sessions & memory

• Sessions are resumable: excalibur --continue (or /resume), persisted under .excalibur/sessions/<id>/.
• Context compaction is automatic and reversible — emitted as an event on the stream, so replay still works. Trigger it with /compact [instructions].
• Durable decisions are promoted to .excalibur/memory/ so future runs start primed.

Time travel, in-session

Every run is an immutable, append-only event log — the stream is the run. The same stream renders the live TUI, this replay, the web dashboard and the audit trail, byte-identical; no other agent is built this way. That's what makes time travel free — hit a wrong turn and you don't start over:

Pick a step → restore it, or fork from cache (the good prefix replays from cache — zero re-spend). Esc Esc does the same live, mid-session.

Configuration

.excalibur/config.yaml controls the shell:

language: auto # auto | en | es  (chrome + responses)
tui:
  theme: auto # auto | dark | light | high-contrast | a custom theme
  flavor: plain # plain | arthurian
  keybinds: # rebind any action to a single key (no modifier combos)
    accept: tab
    cancel: escape

Switch or load a theme any time with excalibur theme, and remap keys to taste — every binding is a single key. Until you connect a model, a deterministic mock runs zero-config so the shell works on first launch; the first real run (or /models) wires a provider.

Next

• Command reference — the complete dictionary.
• Autonomy levels — what each turn is allowed to do.
• Workflows — the recipes the shell routes to.