dislove/evidence-backed-authority-verification

Evidence-Backed Authority Verification for Autonomous Agents

Measuring and Governing Root-Equivalent Execution Paths

A verifier that was asked whether an autonomous agent could reach root on its host, could not prove that it couldn't, and said so. This repository is the paper, the verifier, and every artifact the paper's numbers are computed from.

Verdict	BLOCKED_ROOT_EQUIVALENCE_DOCKER — exclusivity not proven
Paper	39 pages, 17,302 words, 40 references — paper.pdf / paper.md
Evidence	57 enumerated privilege paths across 7 surfaces, one host
Code	83 tests, 15 gate control cases, ruff-clean, zero dependencies
Scale	n = 1. One Fedora workstation, one agent runtime, one moment
Revision	4 — see CHANGELOG.md

The result

verdict                        BLOCKED_ROOT_EQUIVALENCE
specific_reason                BLOCKED_ROOT_EQUIVALENCE_DOCKER
authority_exclusivity_proven   false
conditions                     19 evaluated, 14 met, failed: 06 07 12 17 19
blocking path ids              22  (3 root-equivalent, 1 unknown, 18 unresolved)
evidence digest                ab4ae6bcb450971214b4e4e6a34be75147653826400ccd09c5e3786415e1c9ac

We could not prove authority exclusivity on the evaluated host, and the system says so rather than guessing. That is the deliverable, not a shortfall of one.

Two root-equivalent carriers are measured and present — membership of the docker group, and the write access to the rootful Docker socket that follows from it. No kernel boundary is crossed by either: the DAC check on the socket passes. Authority was delegated by configuration, not bypassed, which is why no sandbox, capability drop or seccomp filter would change the result.

A further 18 paths are unresolved, because the artifacts that would decide them cannot be read without privileged access the agent does not have. Under the model in this paper, unresolved is not a pass.

Start here

No root, no Docker, no network, no dependencies beyond Python 3:

python3 reproduce_verdict.py       # recompute the verdict from the sealed evidence
python3 check_manifest_chain.py    # prove the append-only seal chain is intact
python3 -m unittest discover -s tests

The first is the one that matters. It reads the shipped evidence, re-derives the verdict with the same pure model the verifier uses, and diffs it against the recorded result — so you are checking the reasoning rather than trusting it:

  match  verdict            BLOCKED_ROOT_EQUIVALENCE
  match  specific_reason    BLOCKED_ROOT_EQUIVALENCE_DOCKER

         path set                           recomputed   recorded
  match  root_equivalent_paths                       3          3
  match  authority_equivalent_paths                  0          0
  match  unknown_privilege_paths                     1          1
  match  requires_operator_evidence_paths           18         18

RESULT: MATCH -- the recorded verdict follows from the shipped evidence
        22 path ids block; exclusivity is not proven, as recorded

Full walkthrough with expected output for every command: GETTING_STARTED.md.

Browsing the data

The canonical artifacts are JSON shaped for a verifier — nested, heterogeneous, keyed by path id. data/ holds a flat JSONL view of the same facts so the Hub can index them and you can look before you clone. 143 rows, 8 tables:

Config	Rows	One row is
paths	57	an enumerated privilege path, its terminal state, and its evidence
conditions	19	a verifier condition, whether it was met, and its evidence
controls	15	a gate control case and the verdict it produced
mechanisms	11	an escalation mechanism probed by execution
operator_checklist	18	a privileged read a human must perform, with its decision rule
graph_edges	12	a typed edge: from → relation → to, authorized vs demonstrated
attacks	11	one leaf attack result from the V3 suite
run_history	19	one verifier run: verdict and evidence digest

from datasets import load_dataset
paths = load_dataset("dislove/evidence-backed-authority-verification", "paths")["all"]

These tables are a view, never a source. If a table and an artifact disagree, the artifact is right and the generator is broken. build_tables.py derives them deterministically — same inputs, byte-identical output — and asserts every row count against an independent count taken from the source. Regenerate and diff rather than trusting:

python3 build_tables.py     # RESULT: PASS -- every table matches its source

Three things to know before using them:

• evidence_json is a string, not a struct. The 57 path records use 117 distinct leaf keys between them with incompatible shapes; no single Arrow schema fits. evidence_keys and evidence_bytes are provided for sorting.
• provenance and reclassified are derived by the generator, not fields of the artifact. provenance: carried_forward marks the 16 of 57 paths whose classification was inherited from the source inventory rather than measured again in the final pass.
• mechanisms.has_evidence is false for 4 of 11 rows. That is a real finding rather than a formatting artifact: those four are declared NOT_PRESENT with no recorded measurement, which is in tension with this paper's own rule that absence of observation is not measured absence.

This is not a benchmark. There are no splits, no train/test division, and no task. There are two ROOT_EQUIVALENT examples in the entire corpus. split: all means exactly that. See "Known limitations" below.

What this is

A fail-closed evidence architecture that stops unresolved authority paths from being mistaken for absence. Reasoning is three-valued — measured absence, unresolved possibility, proven impossibility — and only the first and third are compatible with a positive verdict. Unresolved possibility blocks unconditionally.

Absence of observation is not equivalent to measured absence.

The second claim is about how verifiers fail in practice:

A recorded fact is insufficient if a different fact is consumed by the verifier.

Four instances of that failure were found in this system, by this system:

#	Recorded	Consumed	Caught by
1	6 surfaces	6 of the 7 that exist	Coverage gate, once the 7th surface was added
2	a 57-path inventory	condition booleans only	Repeatability condition, when it failed to fail
3	inventory and its measurement context	the inventory, unbound	Control measurement of an unchanged host
4	a terminal state on every path	four summary lists the inventory publishes about itself	Formalising §9 and diffing the model against the code

Finding 1 is structural, not a slip: find -perm -4000 is incapable of discovering Linux file capabilities, so 11 capability-bearing binaries were absent from the authority model entirely. Finding 4 survived three hardening rounds and four rounds of this project's own gates before formalisation caught it.

What this is not

• Not a security certification. A blocked verdict certifies nothing.
• Not complete Linux privilege discovery. Seven surfaces are enumerated; §16.1 of the paper names seven known omissions.
• Not elimination of root-equivalence, nor a proof of universal authority closure.
• Not a general result. n = 1. Every count here is a property of one host at one moment. The method is what generalises, and it has had no independent adversarial evaluation.

Documentation

Guide	Read it for
GETTING_STARTED.md	Every command, with its real output. 5 minutes.
VERIFYING.md	Why sha256sum -c reports mismatches, and why that is correct
GLOSSARY.md	The vocabulary — root-equivalent, admissible, terminal state, UNDETERMINED
FAQ.md	"Just remove the user from the docker group", and 14 other reasonable objections
FILE_INDEX.md	All 73 files: role, size, and which manifest seals each
paper.md / paper.pdf	The argument in full
CHANGELOG.md	What changed each revision, including what was wrong

Evidence integrity

Five append-only manifests seal this package. They are not regenerated when a file changes — a later manifest supersedes the earlier entry and records the superseded digest, so the link from digest to run survives. Running sha256sum -c against any single manifest therefore reports mismatches by design.

check_manifest_chain.py proves the policy was actually followed: every mismatch must be vouched for by another manifest, or it is an unexplained break.

One disclosure. README.md — this file — is sealed in sha256sums.txt at digest 86ec9fa550ea5886e19531c01f1360e820dde24df2f2eac510ff580eb1052e0a, and it was replaced during publication (the previous card stated outdated condition counts). That supersession is recorded in sha256sums.docs.txt with its prior digest, in the same form as every other. It was found by writing the chain checker, not before — a fifth instance of the failure class the paper is about, in the packaging rather than the verifier. VERIFYING.md has the detail.

A note on the host data

The artifacts describe a real workstation: /home/martin, uid 1000, the docker gid, 35 setuid binaries, 11 capability-bearing binaries, polkit and systemd surfaces, and filesystem-visibility state. They are published unmodified on purpose — redacting them would change every digest, force the manifests to be resealed, and destroy the append-only history the paper is about. A paper on evidence integrity shipping evidence that does not verify would be self-refuting.

The disclosure is bounded: no hostname, IP address or MAC address appears anywhere in this package. What is disclosed is a privilege configuration, not a locator, and the headline finding — that docker group membership confers host root — is documented by Docker itself.

Known limitations

Stated here rather than left for a reader to find:

• n = 1, and no independent adversarial evaluation.
• 9 of the 40 bibliography entries carry author/title/venue/year only and are marked % UNVERIFIED-METADATA in references.bib. They are cited for claims the text also supports directly.
• The host collectors are not reproducible by a stranger. privilege_resolution.py refuses to write in any context that cannot prove it measured the host as the agent identity. That is deliberate — it is what Finding 3 is about — and it means an artifact evaluator inside a container cannot regenerate the §13 counts.
• The derived tables leak their own labels. If anyone turns data/paths.jsonl into a supervised task, note that privilege_effect alone determines the classification for 75% of rows and discriminator for 72%, and that 22 of 57 rows are exact duplicates once evidence is excluded. A model can score well without reading a byte of evidence, which is the opposite of what this work is about. Hold those two columns out.
• sha256sums.txt lists 5 files that were never part of the artifact set (harness state and a .pyc), because the find that generated it swept the working tree. Another measurement-hygiene failure in this project's own toolchain; it cannot be corrected without violating the append-only policy, so it is documented instead. See VERIFYING.md.

Licence

Dual, by component:

• Code — every .py file, including tests/ and attack_suite/ — Apache-2.0 (LICENSE). Patent grant included; build verifiers on it.
• Everything else — the paper, the Markdown reports, the JSON evidence and the manifests — CC-BY-4.0 (LICENSE-CC-BY-4.0.txt). Attribution required.

If you reuse the evidence files, cite the paper; if you reuse the model, the Apache notice is enough.

Citation

@misc{acgs2026authority,
  title  = {Evidence-Backed Authority Verification for Autonomous Agents:
            Measuring and Governing Root-Equivalent Execution Paths},
  author = {ACGS},
  year   = {2026},
  note   = {Revision 4. Verdict: BLOCKED\_ROOT\_EQUIVALENCE\_DOCKER,
            authority\_exclusivity\_proven: false. Evaluation is n = 1.}
}

Contact

Corrections and objections are welcome, particularly adversarial ones — the paper argues this system has never faced an independent attacker, and that is still true.

• Community tab on this repository, for anything that benefits from a public thread.
• hello@acgs.ai, for anything that should not be one — including a security report about the host configuration disclosed here.