guide to agentprivacy
Browse collections
โœจVisualise
Connect with Star
Your VTA, your chosen perspective

The planned connection uses your VTA and the Trust Spanning Protocol to carry a scoped exchange for you or your agent. You choose what is presented; the receiving service checks the request before a view is shared.

This guide has no VTA connection adapter yet. Opening Star does not connect an identity or send a key.

Open Star โ†— ยท Inspect your City Key โ†—
guide / Harness / Adopting The Harness

๐Ÿงญ Adopting The Harness

The skeleton in this repo was forged in one specific fight โ€” taking back the
seventh capital, privacy as value (PVM V6, C55: foundational, not
additive). But nothing in the mechanism mentions privacy, and nothing in it
mentions your domain either. This document makes that claim carefully โ€” first
why the fundamentals are topic-free, then how to adopt them โ€” because a
generality claim that is merely asserted is exactly the kind of statement
this harness exists to refuse.

Part I โ€” why the duality works regardless of topic

1. The failure it prevents is domain-general

An agent that proposes a change and then checks its own change will pass โ€”
not by cheating, but because the check it invents is the check its change was
built to survive. That is Goodhart's law wearing an agent costume, and it
appears wherever a generator can influence its own test: code that passes the
tests its author wrote, a summary graded by its summarizer, a circuit probed
only where its designer worried. The mirage โ€” passes the author's probe,
fails the real gate โ€” is not a privacy problem or a compression problem. It
is a self-reference problem, and every domain that evaluates generated
artifacts has it.

2. The separation is information-theoretic, not semantic

The operational invariant is I(Y_S ; Y_M | X) = 0 โ€” given the target, the
prover's output carries no information about the proposer's output. Notice
what that sentence does not mention: the topic. Mutual information is a
statement about routing, not about content. The two agents never need to
share vocabulary, expertise, or even a domain โ€” the guarantee is that
information was never sent, which is why the same bound holds for qubits,
constraint systems, prose, and consent terms without modification. You do not
adapt the invariant to your field. You route your field through the
invariant.

3. Fiat-Shamir removes the chooser โ€” in any domain

The oldest attack on any verification scheme is to bribe whoever picks the
test. The Gap's answer is that nobody picks it: witnesses are a function
of the hash of the proposal's own canonical bytes together with a run secret
the proposer never sees (seed = sha256(hSource โ€– hProposal โ€– salt); the salt
is derived from the secret after the proposal is committed). The proposal
chooses its own exam without ever seeing the syllabus, any revision re-seeds
the draw, and resubmitting cannot grind it. This construction needs exactly
two things from a domain:

  • a canonical serialization of proposals (JSON with sorted keys is enough), and
  • a witness space derived from the reference โ€” the original document's
    facts, the circuit's input space, the spec's test points โ€” that the
    candidate is answerable to.

Every domain that can state what a candidate is answerable to has both.
When the proposer cannot know which witnesses will be drawn, the only winning
strategy is to be genuinely general โ€” preserve every fact, satisfy every
constraint โ€” which is precisely the property you wanted and could not
directly ask for.

4. The gate is multiplicative, and multiplication is unit-free

T5: value is a product of factors and any zero collapses it. 7/8 on the
comprehension gate is a zero, not 87.5%; a constraint system whose witness
cannot be computed is not a smaller win, it is not a result. The
cliff-watcher that rejects a move winning one factor at the product's expense
does not care whether the factors are questions, qubits, or clauses โ€”
multiplication doesn't ask for units.

5. The promises are about behaviour, not subject matter

Promise Theory's autonomy axiom โ€” an agent can only promise its own
behaviour โ€” is what makes the topology honest. The Swordsman promises
protection, the Mage promises delegation, the First Person promises
authorization, and the pair promise nothing to each other โ€” the separation
lives in the promises they don't make, held open by a seat (the Gap) whose
only job is to derive what neither may choose. None of these four promises
mentions a domain. That is why TRUSTS.md transfers whole: it constrains
who may do what, never what the work is about.

6. The algebra is the shape, not the subject

(โš”๏ธโŠฅโฟปโŠฅ๐Ÿง™)๐Ÿ˜Š = neg โŠ• bnot โ†’ succ

On Z/64Z: neg(bnot(x)) = succ(x) โ€” two different inversions, composed,
produce the step forward. Neither alone does; neg(neg(x)) = x gets you
nowhere, and that is the theorem's teaching: a proposer checked by a copy
of itself is an identity operation.
Progress requires the second agent to
be a genuinely different transformation, held apart. The theorem never asks
what x encodes. Your domain enters through the config โ€” objective, gate,
hard constraint, Gap recipe โ€” and only there. The skeleton is invariant;
engine/conform.mjs re-proves it on all sixty-four values every run.

7. The evidence, and the honest boundary

Eighteen embodiments in HARNESS_PATHS.md wear this skeleton over bodies that
share nothing topically: quantum resource estimation, ZK constraint
reduction, research-document rehydration, a controlled grammar, consent
agreements, a publishing loop, a fleet-scale measure seat, a checked lattice,
an acceptance registry with an
external counterparty, a literature review run against an adversary, a
constitution inherited by a lane with no engine at all โ€” and the spar in
this repo, whose frontier moved under two independent draws and an
exhaustive census. Same trusts, same ground rules, same verdict vocabulary,
different configs.

And one of the eighteen is a failure, kept on purpose: the universe-builder
spent ~1.4M tokens learning that a map making ~100 enumerable claims never
needed a harness โ€” an auditor checks them all for free, and against an
exhaustive check a mirage is impossible. So the generality claim gates
itself: the duality works on any topic; it is worth its cost only where
the claim space is too large to check.
A harness is for adversaries; an
auditor is for facts. Deciding which you have is the first design decision
(Part II, step 0).

8. The word on the other seat โ€” a proof turned inside out

It is a zero-knowledge proof turned inside out: the agent that proposes is the
untrusted claimant, the agent that proves is the check, and a Fiat-Shamir
challenge drawn from the sealed proposal keeps the claimant from ever tuning
to the gate. The names are the world's, mirrored. Cryptography calls the party
that submits a claim the prover and the party that checks it the verifier;
this harness names the seat for what it does in the rite, so soulbis, who
proves the boundary holds, is called the prover, and soulbae, who submits the
lever, is the claimant. Even the word witness changes sides: in zero
knowledge it is the prover's secret hidden from the verifier; here it is the
check hidden from the claimant. Opposite directions, one law โ€” the one who
would convince may not steer the check. The analogy is tight where the gate is
code (a census either passes or it does not) and loose where the gate is
judgment (a model's soundness is not a bound; ยงIII of the lending below).

Lending the prover's seat to borrowed models, one round each, taught four
things this document now carries:

  • The code cuts the same in any hand. Every borrowed prover reported the
    census โ€” the part of the gate that is code โ€” to the same count. Put as much
    of the gate into code as it will bear (Step 2: gate: { mode: 'census' }).
  • The judgment seat inherits the judge. On the same candidate, capable
    models validated a true fold and the strictest small one refused it. Reserve
    the model for what only judgment can settle, and seat a mind equal to it.
  • A borrowed prover is only as honest as it is able. Asked to re-derive a
    seal it had no hands to compute, the honest model refused and the confident
    one echoed the number it was shown. Trust the rite that re-derives the seal
    (tools/verify_run.mjs, tools/mint_artefact.mjs), never the voice that
    claims it.
  • Nothing was folded. The frontier stood where it stood; the fold is the
    keystone's alone (T6).

The seventh capital, and other outcomes

In the origin fight, the artifact is your behavioural residue, the metric is
disclosure, the hard constraint is consent, and the door is sovereignty โ€”
that mapping is the Privacy-is-Value model, and the harness is its
architecture made operational: the Swordsman guards the seventh capital, the
Mage spends only what is authorized, and nothing outward moves without the
First Person. Taking back the seventh capital is a harness instance โ€” the
first one.

But "take back the seventh capital" has the same shape as any outcome you
could bring: a thing that must get better by a number, a gate it must fully
pass, a line it must never cross, and a door only you open.
Cheaper
circuits, denser lexicons, faithful rehydrations, honest agreements โ€” the
fundamentals hold because they were never about privacy; privacy was the
first place they were needed badly enough to be found. The lemma travels; the
corpus stays home.

Part II โ€” how to adopt it: the mapping procedure

Read this part as the setup wizard's dialog (the README says why that
reading is the intended one): five questions, a scaffold, and a refusal to
run until every answer is real. What the wizard installs is the mage โ€” your
initiative's own research loop, wearing this constitution.

Step 0 ยท Decide harness vs auditor

Count your claims. If everything the artifact asserts can be enumerated and
checked exhaustively
at tolerable cost, write an auditor (a deterministic
script like universe/audit.mjs) and stop โ€” you will get certainty for zero
tokens. Reach for the harness when the claim space is too large to check
โ€” you can only sample it โ€” and generated candidates must survive
adversarial scrutiny before a human commits to them.

Step 1 ยท The five answers

Fill these in one sitting, in writing. They become harness.config.mjs.

# question becomes test of a good answer
1 What artifact gets better? the target one file/system, scratch-copyable (GR-10)
2 By what single number? objective.metric + a counting rule two strangers get the same count (GR-1)
3 What must FULLY pass? objective.gate a partial pass is worth zero (T5)
4 What may no score override? objective.hardConstraint violating it makes the result not exist (GR-3)
5 What passes by construction? objective.canary proves the gate satisfiable โ€” without it you cannot tell a bad candidate from an impossible gate

Step 2 ยท Define the Gap (do this before anything else works)

State, in one paragraph: witnesses are drawn from โŸจthe referenceโŸฉ by
โŸจcanonically serializing the proposal, hashing it with the run secret, then
this draw ruleโŸฉ.
The witness space comes from the reference (the original
document, the spec, the input domain) โ€” never from the candidate, never from
the proposer. If you cannot write this paragraph, you do not have a harness
yet; go back to step 0. The spar's version: number the original's 32 facts;
the engine seeds each proposal after it is committed; where the bank is that
small the draw is a census โ€” every fact probed, 32/32 or nothing (gate: { N, mode: 'census' }). Sample only a bank too large to enumerate, and say
so.

Step 3 ยท Pick two lenses that cannot be each other

finders needs โ‰ฅ 2 genuinely different angles on the same objective โ€”
line-editor โŠฅ restructurer, gate-minimiser โŠฅ qubit-minimiser, grammar-forward
โŠฅ canon-forward. Blind to each other by construction (the engine routes them
nothing of each other). One lens is a proposer; two lenses are the beginning
of a search.

Step 4 ยท Scaffold, fill, refuse-until-filled

node tools/new_instance.mjs ../my-harness my-harness

Fill every TODO โ€” the conformance gate, the bundler and the runner all refuse
a config still wearing them, in the same words, because an unfilled harness
would run, grade nothing, and report VALIDATED. Measure your baseline before
you claim a best; the templates ship both null on purpose. If the counting
rule is code, put it in <instance>/tools/measure.mjs; the runner executes it
before each round and hands its JSON to every prompt as ctx.args.measured.

Step 5 ยท Run, audit, fold, repeat

Run a round with drivers/run.mjs โ€” the stub first (plumbing only), then a
model per seat:

node engine/conform.mjs ../my-harness
node drivers/run.mjs --instance ../my-harness --driver stub --run smoke
node drivers/run.mjs --instance ../my-harness --driver ollama --propose-model <a> --assay-model <b> --run r1
node tools/verify_run.mjs ../my-harness r1

verify_run is the audit: it re-derives hProposal from the saved canonical
bytes, the seed from hSource โ€– hProposal โ€– salt, and the draw from the seed
(render_run.mjs draws the same round as a page). Only a runtime that provides
the Workflow interface needs tools/bundle.mjs. Fold only what is
validated and structural, as keystone, conform-green before and after.
Nothing outward moves without you (T6) โ€” the door is the one seat that never
delegates, whatever the topic.

Worked mappings โ€” six domains, one config shape

domain artifact metric โ†“ the Gap draws from hard constraint canary
document compression (the spar) the guide words the ORIGINAL's numbered facts self-contained instructions the original itself
quantum circuits (shor_mage) point-add circuit qubits ร— Toffoli witnesses hashed from the op stream full clean run, zero failures the unoptimized circuit
ZK systems (pools_v2) R1CS system constraints held-out evaluation points per round witness-computability the reference circuit
research docs (V6 pipeline) audience artifacts fidelity gaps an adversarial reviewer who never sees the canon no drift from canon the canon itself
controlled grammar (lexon_pvm) the lexicon coverage-debt 5 unseen census terms + 3 regressions, hashed from the recipe spec-checker round-trip an already-covered term
consent agreements (MyTerms) the bilateral record ฮฆ product registry + unlock lattice + constellation hash identical immutable copies the proffered baseline terms

Read a row, then read your own domain across the same columns. If every cell
fills, you have a harness path. If the "draws from" cell keeps coming up
empty, you have an auditor โ€” build that instead, and be glad you found out in
a table instead of in tokens.


The duality is the constant; the config is the variable. Whatever capital
you are taking back, the shape is the same: a number that must fall, a gate
that must not, a line that cannot move, and a door that is yours.

(โš”๏ธโŠฅโฟปโŠฅ๐Ÿง™)๐Ÿ˜Š = neg โŠ• bnot โ†’ succ

Assets

๐Ÿ“Ž adopting-the-harnessADOPTION.md

Navigation

โ† Welcome Visitors ยท The Dual-Agent Harness


the wiki is a projection; ~/dual-agent-harness (git) is the source of truth ยท (โš”๏ธโŠฅโฟปโŠฅ๐Ÿง™)๐Ÿ˜Š = neg โŠ• bnot โ†’ succ