Shisa AI's terminal coding agent.

What it is

A terminal agent built on the Pi coding agent, wired directly into Shisa's serving platform.

Jouzu is where three parts of the Shisa stack meet in one product: the Shisa API serves every model in its catalogue, Shisa realtime transcription powers voice dictation, and TextGuard — Shisa's own Go scanner — checks skills and fetched web content locally before the model ever sees them.

It is a command-line tool first, but ships with a desktop launcher as well. It is explicitly alpha: the README states "v0.1.x is alpha software. Expect frequent updates and changes."

Install

npm install -g jouzu
jz doctor        # non-mutating diagnostics
jz               # start a session in the current directory

jz is an alias for jouzu. It can be run without installing via npx --yes jouzu, and there is a signed Windows x64 installer, the Jouzu Launcher, that bundles every requirement — including its own Node runtime, so the system Node version does not matter.

Requirements: Node.js 22.19+, Git, and Bash (Git Bash on Windows). First launch asks whether to enable the Japanese profile, then offers to connect a Shisa account. New Shisa accounts receive USD 10 in credits.

Models

One catalogue, one API, every model served by Shisa.

The model picker (/model or Ctrl+L) searches providers and models, keeps favourites, and saves per-project defaults. Shisa's catalogue is built in and activates on sign-in. Catalogues are pluggable and publishable — see /catalogs.

The picker lists these nine because they are the ones that declare tool_calling. The account catalogue actually holds fourteen offerings: the five others are shisa-ai/ domain models — two Shisa V2.1 variants, two Chotto models and shisa-de-1 — which declare no capabilities and report maxOutputTokens: 0. They are served, but they cannot be an agent role.

Jouzu is not open-models-only. docs/astra.md documents model-specific handling for GPT-6 Astra against api.openai.com, including thinking levels and prompt-cache options. The router adapts to proprietary frontier models too.

Capabilities

Rather more than a chat loop in a terminal.

Task management

Jouzu keeps a punchlist, runs jobs beside it, and decides for itself when a turn needs a reply.

Given multi-step work, Jouzu creates a numbered task list and works it, marking each item complete as it goes. Background jobs run alongside, and the Session Line carries both — so the state of the work is visible without asking for it.

The list is addressable at any time with /tasks, which offers View all tasks, Create task, an auto-mode toggle (cascade by default), and bulk clear.

Background jobs and flow control

Jobs report back as notifications rather than interrupting. Flow control then decides whether the turn needs a response at all — here the job landed after the work was already finished, so the agent closed the turn with agent_no_reply instead of padding out a reply.

Goals, loops and scheduled work

Four containers for work, widening in scope — and one layer underneath that keeps them honest.

Each container holds state the conversation itself cannot be trusted to keep, and each has its own way of stopping. Tasks are the shared punchlist, covered above. Above them sit goals (one objective, worked until done), loops (repeated, measured iteration) and scheduled prompts (work that fires later). Flow control sits under all four — it is what makes autonomous work safe to leave running.

Goals

A goal is a persistent objective. Lane, mode and scope are derived for you; you can cap what it is allowed to spend.

Loops

Loops run autonomous, repeated work. The bundled pi-multiloop skill describes four modes — and this is where the word punchlist actually lives:

• Each loop owns a lane with independent state. Running several at once means naming the lane in every tool call.
• Loop state is carried by explicit start and resume prompts, tool results, /multiloop status, and compaction-aware resume prompts — so a loop survives the transcript being compacted mid-run.
• Runs are recorded as <lane>/run-<timestamp> and keep a tally of iterations, keeps, reverts, logs, crashes and blocks.

Scheduled work

The schedule_prompt tool registers one-time and recurring prompts. Each stored job carries an id, creation time, an optional session binding, an enabled flag, a run count, and the status and timestamp of its last run — running, success or error. Schedules are a flow wait source: what flow control waits on is the schedule's first trigger, not the completion of the prompt it fires.

Flow control

Flow control is the layer underneath all of the above. It batches background results after the current reply, lets tasks wait on input or on another job, and — importantly — holds input it cannot prove was delivered rather than silently replaying it.

Interrupting a reply also pauses automatic work until your next message. JOUZU_FLOW_CONTROL=0 disables it for a process.

Agents and runs

Roles are declarative, and concurrency is governed.

Definitions live in agents.json (schemaVersion: 1) alongside maxConcurrent and a roles array. Each role carries:

Concurrency. maxConcurrent defaults to 2 and accepts 1–8; the queue holds up to 32 waiting tasks. Roles with write, edit or shell tools run one at a time per workspace, and separate Jouzu parent sessions serialise child writers through a workspace lock — so two agents cannot clobber each other's edits. Main-session edits and external programs do not participate in that lock.

TextGuard

Content is scanned locally before a model sees it.

TextGuard scans skills and web content on the machine by default. Flagged web results reach the model labelled as untrusted data; flagged skills are withheld entirely until approved. Review findings with /textguard; change scanning for a session with /textguard on|strict|off, or start with --jouzu-textguard-strict / --jouzu-textguard-off.

Japanese support

Two profiles ship: core (default) and ja. The ja profile adds Japanese responses while leaving code, commands and paths unchanged — a distinction that matters for a coding tool. Beyond the profile, Jouzu renders Japanese, Chinese, Korean and emoji at correct character widths, which most terminal agents get wrong.

jz profile apply --profile ja
jz profile apply --profile core

The session

The status line carries the working context: provider and model with thinking level, the workspace and git branch with dirty-state flags, context consumed against the window, and tokens up and down.

Command reference

Built-in tools

Provenance

Everything above is drawn from two places, and it is worth keeping them apart.

Verified against a live install on 2026-10-06 (Windows x64, bundled Node 24.19.0): the version strings, the nine-model catalogue, the status line, the TextGuard withholding, the bilingual first run, the desktop launcher, and the jz doctor output.

From the repository at github.com/shisa-ai/jouzu (main, pushed 2026-10-03): the feature list, agent role schema, flow-control commands, tool list, profiles and keybindings.