Architecture control for agentic workflows

Your agent writes the code.
You keep the architecture.

Artisan turns your codebase into a living class diagram: you design in a fluid visual editor, the agent implements at full speed, and artuml keeps track of who changed what.

Open the editor Read the docs

zero dependencies node ≥ 18 C# today · more languages planned opencode · Claude Code · Codex MIT

your-project — zsh

.artisan/diagram.html — the editor, as the agent never sees it

«abstract»

✎

Animal

#Name: string

#Age: int

abstract +Speak(): void

«interface»

IPet

+Name: string

+Play(): void

Dog

-energy: int

override +Speak(): void

+Fetch(): void

Cat

-livesLeft: int

override +Speak(): void

Owner

-pets: List<IPet>

+Adopt(pet: IPet): void

inherits / owns / uses implements agent proposal (amber)

the editor's starter diagram · the agent proposes in amber · you confirm

The workflow

One loop. Two sides.

The human designs, the agent implements, and artuml tracks every change in both directions.

`artuml scan`

C# → diagram: every class, all six UML relations, layered layout, notes preserved. Re-scans merge; nothing you did is lost.

→

You redesign

Drag, rename, rewire, add classes, write notes. Notes bind the agent — they end up in the report it executes.

→

`artuml diff`

Your diagram edits become a markdown report: notes first, renames stay renames, additions are scaffolded.

→

The agent implements

/artisan-scaffold and /artisan-implement turn the report into code. Existing members are never touched.

→

The agent proposes

/artisan-architect lets the agent suggest structure. Its changes appear amber in your editor until you confirm.

→

`artuml ack`

You confirm, both sides sync, and the next scan keeps the picture current. Then the loop runs again.

the human

You make the decisions

Design the architecture in a fluid, click-to-edit canvas
Every class, member and relation carries a note the agent must honor
Review the agent's proposals in amber — accept or push back
Dictate changes from the terminal with artuml add/edit/remove

The agent reads the architecture from .artisan/diagram.puml before touching code.

the agent

The agent does the typing

Reads a markdown diff report instead of guessing intent
Renames are refactored — never delete-and-recreate
Existing members are never modified; additions scaffold or implement
Its own architecture ideas wait for your confirmation

No pack needed — any agent that can run artuml diff works.

Three packages, one loop

One picture, three repos

npm · the hub

`artisan-agent`

One npx command: installs artisan-uml-cli and copies the /artisan-* packs + artuml CLI skill into opencode, Claude Code and Codex. The entry point.

github npm

npm · the editor

`artisan-uml`

The class diagram editor. One self-contained HTML file in your project, a web app in the browser, a layout engine you can import.

editor.artisan-uml.dev npm

npm · the CLI

`artisan-uml-cli`

scan, diff, mark-ai, ack, status, add/edit/remove, editor, serve — everything the loop needs.

cli.artisan-uml.dev npm

Command	What it does
/artisan-scan	scan code → diagram + PlantUML, open the editor (C# only today)
/artisan-scaffold	diagram edits → code stubs
/artisan-implement	diagram edits → real code, per notes
/artisan-architect	agent proposes an architecture change; you review
/artisan-status	pending changes in both directions
artisan-cli	skill: artuml CLI reference — commands, flags, config locations (`npx artisan-agent install`)

Get started

Live in your project in two minutes

installer

$ npx artisan-agent install
# installs artisan-uml-cli globally + copies the /artisan-* packs
# into opencode, Claude Code and Codex command folders
$ cd your-project
$ artuml scan

Don't use the packs? npm i -g artisan-uml-cli and point any agent at artuml diff — full guide.

Why this exists

Agents create architecture. Nobody asked them to.

Drift: new classes, new abstractions, rewired dependencies — nobody decides, everybody pays.
No picture: the architecture lives only in the last prompt that worked.
Lost speed: fighting drift costs more than the speed agents give back.

As a Software Engineer, I like to plan the architecture of my projects with class diagrams. I wanted to bring them closer to the way we build software today, hand in hand with agentic workflows, to make coding fun again.

— Óscar Delgado, oscardelgado.dev

Your agent writes the code.You keep the architecture.