Human Minority Verifier · AI coding-agent verification

Human Minority VerifierMore agents. Same veto.

Human Minority Verifier is a deterministic, source-available verification layer for AI coding agents and agentic coding workflows. The public V1 does not run a complete autonomous software factory. It provides a portable verification path that binds a producer claim, exact candidate bytes, required checks, trusted verifier IDs and verifier-result envelopes to the same candidate before canonical acceptance composition.

The rule behind the project is deliberately narrow: an agent saying “tests passed” or “ready to merge” is still only a claim. The public code checks the bindings and decision inputs instead of treating the producing agent's report as authority.

Claim is not proof.
View the public repositoryRun the public CLI

Early development · public V1 CLI available · artifact stage: EARLY_SOURCE_DROP

What exists today

The public repository is an Early Source Drop, not a finished production platform. These are the capabilities documented and shipped in the current public artifact.

Public CLI and exact candidate identity

The installable human-minority CLI reports the public version, inspects the committed public artifact and evaluates an exact verification bundle. Candidate identity is recomputed from the actual candidate bytes using SHA-256.

Verification contracts

The artifact includes claim, evidence, verification-result and acceptance contracts, plus the same canonical acceptance composition used by the upstream implementation. The public path is not a separate demo-only reducer.

Binding and veto checks

The verifier path rejects missing, extra, duplicate or mismatched results. It also rejects producer/verifier role collapse when the producer is listed as a trusted verifier for the same verification vertical.

Portable supporting primitives

The export includes deterministic JSON and hashing helpers, source and portable-path contracts, bounded repair and scope-policy primitives, provider-neutral credential references, observation/freshness contracts, public tests and integrity checks.

LicensePolyForm Perimeter 1.0.1. Source-available, not OSI open source.
PythonCompatibility target: Python 3.12–3.14.
Runtime dependenciesPython standard library only.

What the public verification path actually checks

Public V1 evaluates a supplied verification bundle. It does not itself prove the real-world identity of a remote verifier and does not execute production provider orchestration.

Read the candidate bytes. The CLI recomputes the candidate SHA-256 instead of trusting a supplied candidate hash.
Bind the producer claim. The claim and candidate identity must agree with the bundle being evaluated.
Require the declared checks. The exact required check IDs and trusted verifier IDs are explicit inputs.
Validate verifier-result envelopes. Results must bind to the same candidate and claim; missing, extra, duplicate or mismatched results are rejected.
Reject producer/verifier role collapse. A producer cannot also be accepted as a trusted verifier for the same vertical.
Compose the acceptance decision. Only the exact required result set is passed into canonical acceptance composition.

The wider control model

Human Minority Verifier is designed around separating claim, verification, repair and authority. The diagram below describes the intended control loop. The current public V1 implements the portable verification portion of this model; it does not publish the complete private execution and orchestration runtime.

task / authority
      |
      v
candidate + claim
      |
      v
bind exact candidate
      |
      v
independent verification
   /       |        \
 FAIL  INCONCLUSIVE  PASS
   |                  |
bounded repair        |
   |                  |
re-verification ------+
      |
      v
human / policy decision
      |
      v
controlled integration

Important: the public source drop contains contracts and primitives for parts of this model, but it does not claim to expose the complete authority → verify → repair → re-verify → integrate runtime.

What this release does not claim

The project documentation explicitly limits the public security and product boundary. The current public artifact does not demonstrate or provide the following:

  • secure execution of arbitrary untrusted repositories;
  • Docker or WSL confinement as a public product guarantee;
  • production agent or provider execution and orchestration;
  • operational deployment machinery;
  • production secret backends or credential custody.
  • cryptographic or remote verifier identity attestation;
  • autonomous repair execution;
  • merge or deployment authority;
  • bundled AI inference credits;
  • stable-production compatibility or support guarantees.

Trusted verifier IDs in public V1 are explicit authority input. The code checks their binding and the acceptance logic; it does not prove who a verifier is in the real world.

Read PUBLIC_BOUNDARY.mdRead SECURITY.md

Artifact integrity is not authenticity

human-minority inspect checks the committed Git HEAD against the committed export-manifest.json: tracked-file membership, file modes, per-file SHA-256 values, the public boundary document and the security contact.

What PASS means

integrity: PASS means the committed tree is internally consistent with its committed manifest. integrity_scope: COMMITTED_HEAD means uncommitted files are outside that integrity decision.

What PASS does not mean

authenticity: NOT_ESTABLISHED is deliberate. Self-consistency alone does not prove that a checkout is an official published artifact. Authenticity requires comparison with a trusted published repository or release reference.

Run the public V1

The public CLI requires Python 3.12–3.14. Installing the package itself does not require third-party runtime dependencies.

git clone https://github.com/Rud0lfoRRP/Human-Minority-Verifier.git
cd Human-Minority-Verifier
python -m pip install --no-deps .

human-minority --version
human-minority inspect
human-minority verify \
  --candidate examples/public_verification/candidate.txt \
  --bundle examples/public_verification/bundle.json

The repository also includes an intentionally invalid role-collapse bundle so the rejection path can be exercised, not only the accepted path.

Frequently asked questions

Is Human Minority Verifier open source?

No. The repository is source-available under PolyForm Perimeter 1.0.1. The project documentation explicitly says it is not OSI open source.

Does Human Minority Verifier currently run AI agents or providers?

Not in the public V1. Production agent/provider execution, operational orchestration and deployment machinery are outside the current public boundary.

Does the public V1 independently run all verification checks?

No. The public verification command evaluates an exact candidate together with a strict verification bundle containing explicit obligations, trusted verifier IDs and bound verifier-result envelopes. It verifies those bindings and the acceptance composition.

Does it cryptographically prove verifier identity?

No. Trusted verifier IDs are authority input in this release. Remote or cryptographic verifier identity attestation is explicitly outside the public boundary.

Can the public V1 merge or deploy code?

No. Merge and deployment authority are not provided by the public artifact.

Why does public code still use seed.app paths?

Human Minority Verifier is the public verifier and CLI surface of the Human Minority product. The exported verification primitives retain their canonical upstream seed.app package paths instead of being copied into a renamed demo-only implementation.