What it is
Kanade (奏 — "to play, to orchestrate") is a local workstation for the AI work I already do. It wraps coding agents in a Windows desktop app with a readable chat surface, an embedded terminal drawer, a file tree, provider lanes, skills, token/context proof, live tool activity, local memory, and release diagnostics in one place.
The headline view is /tsukue: the desk. Chat stays spacious in the center. The terminal is there when I need the raw shell. The side rails keep the work legible: files, skills, sessions, context, logs, diagnostics, and account status without making the conversation feel like a cramped dashboard.
The provider model is account-neutral now. Kanade starts empty, then I bring the lanes I actually use: Claude, Codex, Gemini, DeepSeek, or separate Claude accounts. Each lane keeps its own config directory, model, credentials, working directory, and guardrails. Optional starter presets exist, but the app does not assume my accounts for me.
The public site at kanade.jhinx.dev is the show floor, not the app itself. It has the Forge Relay copy, current screenshots, public docs, and a readable tour of the workstation. The desktop app stays private and local.
Why I built it
The first version was an observatory for Claude Code hook events. It watched every tool call, skill load, prompt, and session end. That was useful, but it still left the actual work split between a terminal window and a browser dashboard.
The pivot was simple: the observatory should become the back of the room. The front should be the desk.
I wanted one place where I could talk to Claude, switch accounts or providers, keep proof nearby, watch context burn, and recover what happened in a previous sitting without spelunking through logs. Grafana watches infrastructure. Kanade watches the work because the work is happening inside it.
The visual register matters too. Kanade is deliberately not another purple AI SaaS page. The app and site use matsubairo green, kin gold, Cormorant Garamond, small-caps labels, and Edo book-plate imagery. It feels like a quiet workshop: dense, calm, old-world, but built for live tool use.
What it does now
- Chat above terminal — a readable chat view with the terminal drawer one move away, so I can stay conversational until I need raw command output.
- Provider lanes — Claude, Codex, Gemini, DeepSeek, and multiple account lanes can sit side by side, each with separate setup and model proof.
- Account setup — scan an existing Claude login, add a lane manually, or import a starter preset. First run is empty by design.
- Guardrails in reach — choose plan-first, guarded edits, bypass modes, effort, and model settings from the same desk instead of digging through config files.
- Context and cost proof — live token usage, context-window percentage, burn rate, remaining estimate, and model-aware cost stay visible while the session runs.
- Skills and files — installed skills are discoverable, injectable, and tracked; the file tree keeps project context near the chat.
- Session memory — live activity, saved sittings, summaries, tool counts, recent-work answers, and compatible session resume are stored locally in SQLite.
- Hermes memory — approved facts move through tiers, project core instructions can be injected into future turns, and the memory ledger can be queried without turning every note into prompt soup.
- Mission Control — local goals, personas, and action plans can be tracked inside the app instead of living only in chat transcripts.
- Forge bridge — Kanade can read Forge project/run state and launch guarded mission runs after explicit confirmation.
- Discord bridge — a private CT-hosted bot can relay signed Discord slash-command traffic into the daemon for controlled remote checks.
- Obsidian bridge — a companion Obsidian plugin talks to the Kanade daemon over a scoped local bridge, so saved sessions, memory, and mission notes surface inside the vault I already write in.
- Adjustable work rails — Project, Files, and Skills can be resized independently, and the right rail now includes a Sessions picker for resuming older compatible work.
- Screenshot-aware lanes — image paste previews stay local, and Codex receives pasted screenshots through its native image path instead of a brittle prompt-only reference.
- Optimize view — repeated failures, noisy workflows, stale skills, and useful follow-up suggestions surface as practical maintenance notes.
- Diagnostics — account state, CLI availability, WebView2 reset tooling, provider status, logs, and crash-recovery surfaces exist because the app has to be testable when it misbehaves.
What I learned
- The safest hook is a file append. Claude Code events write JSON lines to a local spool file, and the daemon tails that into SQLite. The hook never calls HTTP, so the app being down cannot slow down Claude Code.
- A workstation has to earn its density. Putting chat, terminal, files, skills, context, and account setup into one window is only useful if the center stays readable. The design work was mostly deciding what stays close without crowding the conversation.
- Account neutrality is worth the extra setup flow. Built-in default accounts made demos easy, but they were the wrong product shape. Empty first run plus importable presets is more honest and survives real installs.
- Live token proof changes behavior. Context windows stop being abstract when the app shows percentage used, burn rate, cost, and estimated time remaining beside the work.
- Auto-update is product work, not plumbing. Packaging Tauri, SvelteKit, FastAPI, PyInstaller, NSIS, updater signatures, manifests, payload URLs, and installed-file verification turned into its own discipline. A build is not shipped until the installed app actually advances.
- Bridges need guardrails before magic. Forge and Discord both got narrow contracts, explicit allowlists, and real smoke evidence before they became part of the workstation story.
Status & next steps
Kanade is still in private development. v0.12 is installed on the maintainer machine for local release verification, and v0.13 is the private-readiness pass — empty-first guided onboarding with generic provider lanes, the Obsidian companion plugin, and a first run polished enough to survive an install by someone who isn't me. There is still no public download, invite flow, or tester access path.
The site at kanade.jhinx.dev explains the Forge Relay direction, and the docs site has the current memory, mission, Forge, and Discord material. The app itself stays closed-source while the rough edges land.
Near-term work is practical: finish live-provider proof with real direct-mode credentials, get the remaining user-side Discord slash proof, exercise the disruptive Tauri-window paths, and keep the installer/update path boring.