Artifactize

Artifactize: Evaluation-driven development for people and AI agents.

Animation, collaborate in Artifactize: three roles pass one Artifact Graph between them, made of Artifacts, the pieces of the project, each with its own checks. As Director, three people and two AI agents decide what to build and add an Artifact; as Builder, five AI agents build it; as Evaluator, four AI agents and one person check the Artifacts one by one. The new Artifact is RED, so the Artifact Graph goes back to the Builder to fix, then to the Evaluator again, and it turns GREEN. The Director adds another Artifact and changes one, and the Builder and the Evaluator go back and forth again until GREEN.
Example Artifact Graph: a project's PROBLEM.md, SPEC.md, code/ and docs/ are each a part of the project with its own checks. A person reviews the problem; AI agents check that the spec, the document saying what the project must do, solves the problem, that the code's tests check the spec, that the docs explain the code and that the code and docs follow their own rules; the code's tests run as a command.
Real recording of the Artifactize desktop app over four Runs of an example project: failing parts turn red, are fixed between Runs, unchanged work is reused, and the fourth Run passes.
Each box is an Artifact, a piece of the project with its own checks; the lines between them make up the Artifact Graph. Real recording of the desktop app preview: four Runs of an example, each one pass through the project's checks, eight times faster.

Who is it for?

How it works

  1. Evaluations define the result; AI agents iterate until it passes.
  2. Tests, AI agents and people can all be equal evaluators, each good at different evaluations.
  3. Each evaluated result becomes part of the next evaluation, all the way to the final result.

The story

Watch a project grow.

Each step below describes the project at that point; the animated graphic beside it shows the same.

01An idea

It starts with an idea.

A few notes on what to build. There is nothing to review yet.

One idea, with no checks.

02Artifacts

The plan and specification become Artifacts.

Choose pieces to review separately. An AI checks whether the specification covers the plan.

The plan and specification become two Artifacts with one AI review.

03Checks

Code arrives, and checks connect the parts.

Compare pieces with each other. Alice approves the specification before work builds on it.

The code is compared with the specification; Alice signs off the specification.

04Tests and style

Tests and a style review check the code.

Tests check the code. AI checks its style against a guide approved by Alice.

Tests, an AI style review and Alice’s approval are three different checks.

05Modules

The code splits into modules.

Give smaller code pieces their own checks so changes can be reviewed where they matter.

The code splits into three parts, each with its own tests and review.

06Beyond code

A website and docs pages join the graph.

Check writing and design too: compare the guides with the app connections they describe.

Documentation and website checks join, with Dana’s design approval.

07A change

Change one module, and only what depends on it runs again.

Change those app connections. Only their checks and the checks that use them run again.

The changed app connections and their users are checked again; unrelated results still apply.

08It keeps growing

New Artifacts and relations keep arriving.

Add new work and connections without redesigning the project’s review process.

A sync part, a brand guide and their checks join the project.

09Work in parallel

Work on your own copy of the project.

A shared review store lets teammates reuse reviews earned in each other’s project copies.

Alice, Bob and Carol work separately and share their review results.

10Merge and check

Bring changes together and check only what is new.

Bring changes together. The team checks review the new combinations and read shared results without changing them.

The combined project reuses existing reviews and checks the new combinations.

See it in the desktop app

Artifactize's own Artifact Graph growing, recorded in the desktop app.

Recorded in the desktop app preview, played back faster.

Real recording of the Artifactize desktop app showing Artifactize's own project graph growing release by release, from 0.7.0 to the current release.
Artifactize’s own project graph, one step per release from 0.7.0 to today.

Get started

Try it in five minutes.

Artifactize is open source under the Apache License 2.0. It runs on Linux, macOS and Windows; the quick start reviews an example project without an AI account or provider access key.

The app brings the artifactize command with it. On a Mac, open the app once to set up the Terminal command. On Ubuntu 22.04, Debian 12 or later, open the .deb with your software installer or run sudo apt install ./Artifactize-amd64.deb.

Or install from the command line

# Linux (x86_64, aarch64): installs to ~/.local/bin, no sudo; on x86_64 also the desktop app
$ curl -fsSL https://artifactize.dev/install.sh | sh
$ artifactize --version
# macOS (Apple silicon, Intel) with Homebrew
$ brew install lhj6102/tap/artifactize
$ artifactize --version
# Without Homebrew: installs to ~/.local/bin and the app to ~/Applications, no sudo
$ curl -fsSL https://artifactize.dev/install.sh | sh

With Homebrew, the app and the commands: brew install --cask lhj6102/tap/artifactize

# Windows x64 from the Microsoft Store, with the desktop app; then open a new terminal
PS> winget install 9PB6W4LL165D --source msstore
PS> artifactize --version
# Without the Store, in PowerShell with no administrator rights
PS> irm https://artifactize.dev/install.ps1 | iex

The PowerShell download is not code-signed, so Smart App Control may block it; the Store version is signed by Microsoft.