lavish-axi: a local review loop for agent-generated HTML artifacts

The gap lavish-axi fills between an HTML artifact and the next agent turn

Agents are good at producing rich HTML artifacts. The README is blunt about what happens next: the human-agent collaboration loop on those artifacts is lacking and falls back into screenshots and long responses for "tell me what to change." That fallback throws away the property HTML is best at, interactivity.

The intended user is someone already running a capable coding agent that emits HTML for plans, comparisons, diagrams, tables, code views, or reports. If your agent writes markdown and you read it in a terminal, this tool has nothing to do. If your agent writes an interactive page and you keep pasting screenshots back into the chat, the mismatch is the problem lavish-axi addresses.

The project describes itself as an AXI, which in its own framing means a CLI any capable agent can run without setup, optimized for agent ergonomics with TOON output, long polling, and contextual disclosure. That framing matters for adoption: the interface is the command line, and the human-facing part is a local browser UI, not a hosted service.

How the agent, the CLI and the browser UI hand work back and forth

The README's diagram is a four-stage loop. The agent writes artifact.html. Running lavish-axi <file_path> opens a local browser UI. The human annotates that page. Feedback then goes back to the agent.

The pieces visible in package.json support that shape. express and ws are dependencies, so the browser UI is served locally and talks back over a WebSocket. chokidar watches files, which fits a review loop where the agent rewrites the artifact while you are looking at it. parse5 parses the HTML, which is what makes element-level and text-range annotation possible rather than a screenshot. open launches the browser. The CLI entry point is dist/cli.mjs, exposed as the lavish-axi binary.

One design consequence is worth naming. Because annotation is structural, the editor has to map your selection back to something the agent can act on. That is a different contract from leaving a comment on a rendered image, and it is the reason the tool exists at all. The README does not document what happens to annotations when the underlying HTML changes under a live session, so treat edits during review as something to verify on your own artifacts.

Installing the Lavish skill with npx skills add

The recommended path is the Agent Skills format. One command installs it, and the README states that is the entire setup, with no npm install needed.

npx skills add kunchenguid/lavish-axi --skill lavish

The skill teaches your agent to run Lavish through npx -y lavish-axi, so the CLI is fetched on demand. It stays a short stub and points the agent at npx -y lavish-axi --help, design, and playbook for current instructions, which is how an installed copy avoids going stale against a newer CLI. By default the skill lands in the current project's skills directory, such as .claude/skills/; adding -g installs it for all projects under ~/.claude/skills/.

In agents that expose skills as slash commands, such as Claude Code, you can invoke it directly.

/lavish let's discuss our plan here

Otherwise, ask for anything easier to grasp visually and the agent loads the skill when it recognizes the task. If you would rather not install anything at all, the README gives a zero-setup route: tell the agent to use npx -y lavish-axi to write a plan. The CLI comes along on demand. Note the Node requirement in package.json: engines specifies node >=22.

Hooks and plugin registration, and where they stop working

Two alternatives to the skill exist, and they are not a stack. The session hook feeds ambient context into every agent session instead of loading on demand.

npm install -g lavish-axi
lavish-axi setup hooks

This installs a SessionStart hook for Claude Code, Codex, OpenCode, and GitHub Copilot CLI that surfaces open sessions, visualization playbooks, and usage guidance at the start of each session. Unlike the skill, the hook also shows your live open sessions, so a fresh session can resume an in-flight review. The README says to restart your agent session afterward so the hook takes effect. That restart is a real step people skip.

The plugin route uses the Agent Plugin packaging standard. No marketplace is involved: the installed npm package is the plugin, because plugin.json sits at the package root next to skills/. Register it with lavish-axi setup plugin, which reports which supported clients were absent. It is opt-in and idempotent, and it repairs the registered path after a reinstall or relocation. Each client registers independently, so one failure does not block the others.

Here the coverage ends. Codex and ChatGPT install plugins only from marketplace sources, so Codex users are directed to the session hook instead. Lavish declares no MCP server, so a plugin install brings the same lavish skill rather than an additional capability.

What lavish-axi does not do

The core feedback loop is local and has no cloud dependency, and hosted sharing through third-party ht-ml.app is explicit and opt-in. If your review process requires a shared link that several people open at once, you are outside the core loop and inside someone else's service.

The repository also ships an internal lavish-design brand skill for maintainers. Default npx skills add ... --list and skills.sh discovery hide it unless INSTALL_INTERNAL_SKILLS=1 is set, so a normal install will not surface it. Do not expect it to appear.

The README does not document rollback for the hook or the plugin registration. There is no uninstall command described for either, and the README does not state how to deregister a client once setup plugin has written its path. If you manage developer machines centrally, that is the gap to close before rolling the hook out broadly.

Finally, the project is young. The release history shows v0.1.60, v0.1.61, and v0.1.62 landing on 2026-08-24 and 2026-08-25, three releases inside roughly thirty hours. The last push was on 2026-08-25. Rapid patch releases at that cadence mean the CLI surface can move while your installed skill stub stays put, which the stub's design mitigates but does not eliminate.

How lavish-axi compares with plain markdown review

The obvious alternative is not another editor. It is the workflow most agent users already have: the agent writes markdown, you read it in the terminal or a diff view, and you reply in prose. That approach has real advantages. Markdown diffs cleanly, it renders in every code host, and the review artifact is text you can grep. Nothing about that is broken.

The difference is what the artifact can express. A markdown plan cannot hold an interactive diagram you can rearrange, and the README's own framing is that a rich editor is not rich enough for some of this work. Lavish adds Mermaid whiteboard editing on diagrams the agent authored, so the human can change the diagram rather than describing the change in a sentence. That is the concrete delta: the feedback channel becomes the artifact itself instead of prose about the artifact.

The cost is a browser UI, a running local server, and a Node >=22 runtime. For a short text plan, that overhead buys nothing. For a design exploration or a technical plan where the layout carries the argument, it removes a round trip.

Licence and the cost of keeping up

The repository is MIT licensed, and the published package includes LICENSE and THIRD-PARTY-NOTICES.md in its files list. MIT is permissive and imposes no copyleft obligation on your own code, but the package bundles third-party dependencies, and THIRD-PARTY-NOTICES.md is where those notices are collected. If you redistribute the package or vendor it into an internal registry, read that file rather than assuming the top-level licence covers everything. This is a description of what the repository contains, not legal advice.

Upgrade cost depends on which path you chose. The skill path is the cheapest to maintain by design: the stub sends the agent to the CLI's own --help, design, and playbook output, so a newer CLI is picked up through npx -y lavish-axi without reinstalling the skill. The hook and plugin paths install a global package, so they follow your global npm upgrade cadence, and the plugin registration repairs its path after a reinstall or relocation. Given three releases in about thirty hours during late August 2026, pinning a global version and upgrading deliberately is more predictable than tracking latest.

Editorial conclusion

Adopt lavish-axi if your agent already produces HTML artifacts and the review step keeps collapsing into screenshots and prose. Skip it if your artifacts are plain markdown, or if you need a hosted, multi-user review surface, since sharing through third-party ht-ml.app is explicit and opt-in. Before committing, run npx -y lavish-axi --help on one real artifact to confirm the CLI and browser UI work on your platform, and check that your agent harness can load a skill or hook, because Codex and ChatGPT take plugins only from marketplace sources.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. Release notes