Artifactize

The AI-native collaboration layer for one-of-a-kind teammates and their agents.

Artifactize splits a project into Artifacts (code, docs, designs, images), each with its own evals: tests, LLM reviews and human sign-offs. Every teammate, human or agent, works their own way on their part, and integrating that work never pays for the same review twice: 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.

Why I built it

Building games with AI, working alone got fast, but working with others still felt like hitting a wall. There had to be a sweet spot between traditional development and AI-native work. So I looked for a way for every teammate, human or agent, to keep their own style and still add up to one coherent result, and I structured the project around evaluation.

Artifactize is that collaboration layer: it splits a project into modules that each carry their own evaluation criteria, so everyone can work their way, and it cuts the evaluation cost wasted during integration.

See it in your terminal

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

How it helps a team

• Each part carries its own bar. An Artifact declares the evals that judge it: 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. Whoever works on a part, in whatever style, meets the same bar.
• Integration reuses 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. Review cost follows the size of a change.
• Centralize the reviews, not the repo. One artifactize server shares verdicts across teammates' checkouts and CI, so a branch's reviews carry over to the merge and a person signs off a change once.
• 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.
• Human review in the terminal. artifactize monitor shows Runs as they progress and hands a waiting sign-off to artifactize review.

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.3

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.3 --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).

License

Licensed under the Apache License, Version 2.0.