Independence Is Not a Boolean

Agent systems increasingly emit verdicts: allow or deny a tool call, accept or reject an artifact, validate a workflow, attest to a result, approve a transaction, or certify a governance decision. The tempting shortcut is to attach a field such as independent=true and move on.

Two forms of independence are easy to conflate.

Computational independence asks whether a verdict was produced through a process that is operationally separate from the artifact or decision being judged.

Normative independence asks a harder question: who decided that the evaluator counts as independent, under which authority, with what incentives, and relative to whom?

A second process may be computationally separate while still sharing ownership, economic incentives, registry control, policy roots, or other dependencies with the subject it evaluates.

Third-party is not the same as independent.

A third party can still be affiliated. A registered mediator can still be admitted by a registry controlled by the same governance operator. A signed verdict can still encode a policy chosen by the evaluated party.

That does not make these signals useless. It means the system should describe what is actually known instead of compressing multiple trust assumptions into one label.

Make the relationship decomposable.

A verifier should be able to reconstruct the basis for the claim. A minimal record could expose fields such as:

{
  "issuer_id": "mediator:example",
  "subject_id": "artifact:example",
  "source_class": "registered_independent",
  "relationship_class": "no_shared_stake_claimed",
  "authority_basis": "registry:example",
  "registry_snapshot": "sha256:...",
  "evidence_ref": "sha256:..."
}

The important change is conceptual: registered_independent is not universal truth. It is a claim tied to an issuer, a relationship, a registry state, and an evidence basis.

A possible disclosure ladder.

Different systems may choose different names, but a useful disclosure ladder could look like:

Each step should carry its own evidence and authority basis. Moving right should not silently erase the trust roots that made the classification possible.

The registry does not disappear.

Suppose a registry decides which mediators count as independent. That registry now sits in the trust path. Its admission policy, operators, snapshot, revocation rules and possible conflicts are part of the verification surface.

The correct conclusion is not that independence is impossible. It is that the system should expose where the trust root lives.

Why this matters for agents.

Tool authorization, workflow governance, mediator verdicts and agent-to-agent review are all moving toward machine-consumable decisions. Once another agent is expected to trust those decisions automatically, ambiguous trust labels become executable risk.

A downstream policy may accept one source class and reject another. That only works if the source class can be traced to evidence rather than accepted as self-description.

Trust improves when systems stop saying “independent” and start showing what independence means in this specific relationship.