Artifactize

Review cost follows the size of a change. Still-valid reviews are reused; you pay only for what changed.

Declare every Artifact (code, docs, designs, images) and the evals that review it: tests, LLM reviews and human sign-offs. While an Artifact's fingerprint is unchanged, its GREEN or RED result is reused. Artifactize is open source under the Apache License 2.0 and runs on Linux and WSL 2.

See it in your terminal

Change one file: status predicts one execution and names the file, and verify re-reviews only that Artifact.

Why artifactize

• Reuse every review that still holds. You define each Artifact's fingerprint; the built-in one hashes the Artifact's own files. While the eval and the fingerprints of the Artifacts it depends on are unchanged, verify reuses the earlier verdict, from any profile, and reports what it executed, what it reused and the tokens reuse saved.
• Know what a change will cost before you run it. status predicts what verify will execute, reuse or wait for, and names the files and dependencies that changed.
• Tests, models and people in one graph. Runtime evals run commands; Agent evals ask one exact model (OpenAI or Anthropic API key, or a ChatGPT/Codex sign-in) with the read-only tools you declare; Human evals wait for a sign-off. RED blocks what depends on it.
• Human review in the terminal. artifactize monitor shows Runs as they progress and hands a waiting sign-off to artifactize review.
• Centralize the reviews, not the repo. One artifactize server shares verdicts across machines and CI.

Install

On Linux (x86_64 or aarch64) or WSL 2, install the static binary from the latest GitHub release into ~/.local/bin. The script checks its SHA-256 and needs no sudo:

curl -fsSL https://artifactize.dev/install.sh | sh
artifactize --version          # artifactize 0.5.2

Prebuilt binaries are attached to releases from 0.5.2 on. To update, run the script again; to uninstall, rm ~/.local/bin/artifactize. Your state (~/.local/state/artifactize by default) is kept.

With a Rust toolchain and a C compiler, install the latest release from crates.io instead (or fetch the prebuilt binary with cargo binstall artifactize):

cargo install artifactize --locked

Releases are also tagged on GitHub, and cargo install can build one from there:

cargo install --git https://github.com/lhj6102/artifactize --tag v0.5.2 --locked artifactize

To build from source instead:

git clone https://github.com/lhj6102/artifactize
cd artifactize
cargo install --path crates/artifactize --locked

Experimental: on Windows (x64), install from PowerShell:

irm https://artifactize.dev/install.ps1 | iex

Install covers the prerequisites, the Agent backends, state and uninstalling.

A tiny example

A folder with an artifactize.json is an Artifact. This one, from examples/runtime-relations, checks that a page has a heading, and "fingerprint": {} makes the result reusable while the folder is unchanged:

{
  "name": "usage",
  "fingerprint": {},
  "evals": [
    {
      "id": "heading",
      "title": "The page has a top-level heading",
      "profile": {
        "kind": "runtime",
        "command": "grep",
        "args": ["-m", "1", "^# ", "page.md"],
        "timeoutMs": 5000
      },
      "payload": {
        "instruction": "Check that {usage} starts with a top-level heading."
      }
    }
  ]
}

No model or API key is needed to try it:

git clone https://github.com/lhj6102/artifactize   # the example projects
cd artifactize/examples/runtime-relations
export ARTIFACTIZE_STATE_HOME=$(mktemp -d)   # keep the tour's state apart
artifactize verify --all    # three GREEN results, exit 0
artifactize verify --all    # exit 0 and nothing executes: all three results are reused

The Quick start continues with status, a family of Artifacts and a Human sign-off.

Reuse

verify reviews once; the next verify reuses every result whose eval and fingerprints are unchanged and says where each came from.

Fingerprints and reuse · Runs, status and validation

Human review in the terminal

verify --wait keeps the Run alive while a Human eval waits. In the monitor, o opens the waiting request in artifactize review: run the tools its owner declared, submit the verdict through a form, and the Run finishes.

Human reviews

Team review store

Each machine keeps its own checkout and state. One artifactize server keeps the verdicts by reuse key and returns the latest, so a review done on one laptop is reused on the next and in CI. A read-only CI token reuses but never publishes.

Team review store · CI · Walkthrough

Documentation

Everything else is at artifactize.dev/docs:

• Concepts: Artifacts, evals, fingerprints, Runs and status.
• Guides: Agent evals and backends, Human reviews, the team review store and CI.
• Reference: every command and flag, artifactize.json, tools, state, limits and the review store protocol.
• Examples: runtime relations, Agent and Human tools, families.

The recordings above are reproducible: their VHS tapes and demo projects are in website/demo (how to record).

Artifactize is a lean Rust port and rebrand of CCDD 7.0.0 (cbf28b4); the plan records the scope.

License

Licensed under the Apache License, Version 2.0.