Verify

Boundry Verify

Boundry takes execution out of the model's hands.

The Boundry Substrate decides whether a submitted request may run, then executes it deterministically and signs a record of both. No model is loaded or called in governed operation. Boundry Verify checks that record, offline, on your own machine.

Patent pending Local-only Read-only Works offline

Why execution is separated

Taking execution out of the model's hands makes its actions checkable, and it is the first condition for governing them.

Language models, and the agents built on them, do not give the same answer twice. Instructions and guardrails shape what a model proposes. They do not make its output repeatable. A record of what such a system did cannot be checked by asking it again.

If that system's output is also the action, the action inherits the problem. It can be logged, but the log is the only witness, and the operator holds it.

It also means the only thing standing between a goal and an action is the author's own restraint. An agent that is told no can look for another way to the same goal, and when its output is the action, nothing outside it has to agree first.

A rule only binds something that cannot act around it. While a model's output is the action, a rule is advice that the model may or may not follow. Once execution sits outside the model, a rule has somewhere to be applied: the point where the Substrate decides whether work runs.

On the governed road (the path from a submitted intent to its record, inside the Substrate), whether work runs is decided by the Substrate, not by whatever authored the request, and a refusal is itself a signed record with its reason (E4). Governance means making the rules and enforcing them. Boundry is designed so that the rules are declared by the people who run it, never by the model that writes the request. Boundry does not decide what those rules say; it enforces them. What this kit shows today is the refusal side of that (E4). That holds for work submitted to the Substrate; a system that acts by some other route is outside it.

Boundry moves three things out of the author's hands and into a system that can be replayed and checked: the decision whether the work runs, the execution of it, and the record of both.

Boundry Verify is how anyone checks that record: that the plan executed is the one the request produced (E1), that each step from request to output is bound together (E6), that the same request executes to the same bytes (E2), and that nothing has changed since (E3).

The Boundry Substrate

It decides whether work runs, and then it executes it.

THE USUAL PATTERN BOUNDRY Prompt Model the output is the decision Action Logs kept by the operator What happened is reconstructed afterwards, from the logs. Submitted intent GOVERNED OPERATION no model loaded or called (E5) admissible? no Refused a signed record, with its reason yes Sealed plan, then output each link hash-bound (E6) Kernel export signed payload bytes · form hashes the bodies it names · the intent as submitted read on your machine, offline Boundry Verify
THE USUAL PATTERN Prompt Model the output is the decision Action Logs kept by the operator What happened is reconstructed afterwards, from the logs. BOUNDRY Submitted intent GOVERNED OPERATION no model loaded or called (E5) admissible? no Refused a signed record, with its reason yes Sealed plan, then output each link hash-bound (E6) Kernel export signed payload bytes · form hashes the bodies it names · the intent as submitted read on your machine, offline Boundry Verify
D1 · Where the decision sits. In the usual pattern the model's output is the decision and the logs are the operator's. In Boundry an intent enters governed operation, admissibility is decided before anything runs, and both outcomes leave a signed kernel export that Boundry Verify reads on your machine.

The Boundry Substrate performs governed execution. It is not a store of records made elsewhere: the runs in the evaluation kit are the Substrate's own, made in fresh processes against fresh roots, on macOS arm64 and Linux aarch64.

A person, a program or a model may write an intent. Whatever wrote it, it enters as a submitted intent, and everything after that happens on the governed road, where no model is loaded or called (E5).

On the governed road, governance and execution are one process. The Substrate first decides admissibility: an inadmissible request is refused, and the refusal is itself a signed record with its reason (E4). An admissible request becomes a sealed plan, whose identity is a deterministic function of its inputs: versions, intent hash, input hashes and pins (E1). The Substrate executes it, each link from intent to output hash-bound (E6). The decision and the act are made by the same system in the same run, and both leave the same kind of record: a kernel export, the Substrate's signed record of one run, carrying the record's own signed payload bytes, its form hashes, the bodies it names, and the intent as submitted.

Records are tenant-scoped; a tenant scope says which records a read is for. A read with no declared tenant scope is refused, never widened, and the Substrate's own absent-scope refusal ships inside the verifier.

One key signs every record in the kit, and the kit ships only its verifying half. A valid signature shows that key signed the record and that it has not changed since. It does not show that anyone independent saw it happen.

Admissibilitydecided first, and a refusal is a signed record with its reason (E4)
Identitya plan's id is a function of its inputs; the body is under the seal's hash (E1)
Determinismthe same request, byte-identical on two platforms (E2)
Linkageeach link from intent to output is hash-bound and recomputes offline (E6)
No modelnone loaded or called in governed operation (E5)
A recorda kernel export, signed, with the intent as submitted beside it

On this page, governed execution means these six things together, each a README claim about the records in the evaluation kit, each held by a named check.

Why deterministic execution matters

Determinism turns a record into a claim anyone can check.

The kit measures determinism: the same governed request, run on two platforms by different people, produced byte-identical outputs, plan body, result and payload signatures; only wall-clock stamps, and hashes taken over them, differ (E2). The measurement matters less than what it makes possible.

A plan's identity can mean something

Because execution is deterministic, an identity that is a function of the plan's inputs (E1) names one outcome rather than a family of them. Two runs that share those inputs are expected to agree, and where they differ, the answer names each differing field and marks the expected ones with the reason. A difference is a finding, not noise.

README · E1, E2

Comparison can replace re-execution

If two runs of the same request must agree byte for byte, checking a run means comparing hashes: against another run, or against the run's own record. That is what compare_runs does, and how a changed output byte, a forged hash or a lost output is caught. The Substrate does not have to be present, and nothing is re-run.

README · E2, E3, compare_runs

The author drops out of the chain

With no model loaded or called in governed operation (E5), and execution deterministic (E2), what a run produced is fixed by its inputs (E1). Whatever authored the intent, the record does not depend on it. The record carries the intent's hash, not the author's account of the intent.

README · E5, E1, E6

The ceiling still applies. The determinism shown is for the governed road, on the workloads in the kit, across the platforms named. Nothing on this page climbs above that.

Why independent verification follows

A verifier needs only what the record carries, so it can be small, offline and separate.

Put the properties together and the verifier's shape is forced rather than chosen. A plan's identity recomputes from six inputs, so anyone who has them can recompute it (E1). Each link from intent to output is hash-bound, so it recomputes offline (E6). The payload is signed and one verifying key ships, so a signature checks without the signer present. Runs are deterministic, so a run is compared by hash rather than re-executed (E2, E3). And no model is loaded or called on the road (E5), so nothing in the run has to be trusted rather than recomputed.

So a verifier needs the record, the intent as submitted, and a verifying key, which is exactly what each run in the kit ships. It needs no network, no database, no emitter, none of the Substrate's dependencies, and nothing that signs. Boundry Verify is built to that shape: seven read-only tools, standard library only, on your own machine.

So each question a reviewer asks has a record behind it, not a log:

What was actually asked?
The record carries the intent's hash, and the intent ships beside the run; a changed intent breaks the first link.
E6
Which plan actually ran?
The plan's identity recomputes from its inputs; the body is under the seal's content hash.
E1
Would it run the same way again?
The same request gave byte-identical outputs, plan body, result and payload signatures on two platforms.
E2
Could anything have refused it, and would we know?
An inadmissible request is refused, and the refusal is a signed record with its reason.
E4
Was a model in the loop?
No model is loaded or called in governed operation; the kit ships this as a result.
E5
Has the record been changed since?
A changed output byte, a forged hash or a lost output is detected, by hash comparison.
E3
Do I have to trust the operator's copy?
Each link recomputes offline, on your own machine, with a package that holds verifying keys and nothing that signs.
E6 · kit

The architecture

Two boundaries, and what each one keeps out.

The first boundary is where governed operation begins; inside it, no model is loaded or called (E5). The second keeps the verifier independent of the thing it verifies: a separate package, on your machine, with nothing that signs.

Submitted intent the record carries its hash, not the intent (E6) GOVERNED OPERATION BEGINS · NO MODEL LOADED OR CALLED (E5) The Boundry Substrate deterministic on the governed road refuses an inadmissible request refusal is a signed record (E4) seals a plan id a function of its inputs (E1) executes it byte-identical, two platforms (E2) The record a kernel export: signed payload bytes · form hashes · the bodies it names · the intent as submitted INDEPENDENCE · A SEPARATE PACKAGE · VERIFYING KEYS, NOTHING THAT SIGNS Boundry Verify runs on your machine · reads folders you name · contacts nothing · writes nothing · cannot sign read-only · offline
Submitted intent the record carries its hash, not the intent (E6) GOVERNED OPERATION BEGINS NO MODEL LOADED OR CALLED (E5) The Boundry Substrate deterministic on the governed road refuses an inadmissible request the refusal is a signed record with its reason (E4) seals a plan its id is a function of its inputs (E1) executes it byte-identical on two platforms (E2) The record a kernel export: signed payload bytes · form hashes the bodies it names · the intent as submitted INDEPENDENCE · A SEPARATE PACKAGE VERIFYING KEYS, NOTHING THAT SIGNS Boundry Verify read-only · offline runs on your machine · reads folders you name contacts nothing · writes nothing · cannot sign
D2 · Layers and boundaries. A submitted intent; governed operation, with no model loaded or called; the Substrate, which refuses, seals and executes; the record; and Boundry Verify on the far side of an independence boundary.

Core principles

Five things the records let you check.

Authorship is separate from execution

The intent is submitted; governed operation does the rest. The record carries the intent's hash, and every link recomputes offline.

README · E6

No model in governed operation

No model is loaded or called in governed operation. The kit ships this as a result (E5).

README · E5

Governance is recorded

A plan's identity is a function of its inputs; the body is identified by the seal's content hash; the output's hash is in the record; the payload is signed.

README · E1, E3, the evaluation kit

Refusal is a recorded outcome

The Substrate refuses an inadmissible request, and the refusal is itself a signed record with its reason. The kit's three workloads include one refused request.

README · E4, the evaluation kit

Verification is independent

A separate, read-only package on your machine. The kit ships verifying keys and nothing that signs; an evaluator verifies and does not re-sign.

README · What it is, the evaluation kit

Where Boundry Verify fits

The verifier for this architecture, not the architecture.

Nothing above is done by Boundry Verify. The Substrate refuses, seals, runs and records. Boundry Verify reads the records the Substrate leaves and checks them on your machine, with the Substrate nowhere in the picture: no database, no emitter, no network.

Trusting a record should not require trusting the system that wrote it. The architecture above is what makes that possible; the verifier is built to be able to do no more than the architecture requires. It has seven tools, all read-only, and there is no write tool and no disabled one.

Works offline, on your machine. It opens no socket and contacts no endpoint. That is held by a named check that reads the package's own imports, with a planted control the check must reject.
ToolWhat it answers
verify_recorda record in, the verifier's verdict out
get_envelopeone envelope, tenant-scoped
query_envelopesenvelopes in scope
chain_statushead, era, manifest seq, sweep figures, instrument named
explain_recorda record's provenance, rendered from artefacts; for a kernel export, its lineage link by link
check_plan_identitya sealed plan's id recomputed from its six inputs, and its seal checked
compare_runstwo runs, each against its own record, then field by field: EQUIVALENT, DIVERGENT or UNREACHABLE

The table is the README's. Every tool takes corpus_dir, by label or path, and every tool declares itself read-only in its own declaration.

IT CAN IT CANNOT read the folders you declare, by label recompute a sealed plan's id and check its seal walk each link from intent to output compare two runs field by field, by hash give a verdict on a sealed record report what it can see of a folder sign write open a socket or contact an endpoint attach to a database or subscribe to an emitter read an undeclared folder or follow a link out of a root re-execute: a comparison is of hashes
IT CAN read the folders you declare, by label recompute a sealed plan's id and check its seal walk each link from intent to output compare two runs field by field, by hash give a verdict on a sealed record report what it can see of a folder IT CANNOT sign write open a socket or contact an endpoint attach to a database or subscribe to an emitter read an undeclared folder, or follow a link out of a root re-execute: a comparison is of hashes
D4 · What the verifier can and cannot do. The first list is what the seven tools answer. The second is what the package's own checks hold it cannot do.

What can be established

Six things the evaluation kit lets you check, and what it does not show.

Each line below is the README's claim, shortened. The README's exact wording, and the check that holds each one, are at The evaluation kit. The scope of every one is: records in the evaluation kit.

E1 · A plan's identity is a deterministic function of its inputs.

Versions, intent hash, input hashes and pins. It does not identify the plan body; the body is identified by the seal's content hash, and the answer says so.

E2 · The same governed request gave byte-identical results on two platforms.

macOS arm64 and Linux aarch64, in fresh processes, by different people on different machines: outputs, plan body, result and payload signatures identical. Only wall-clock stamps, and hashes taken over them, differ.

E3 · Tampering after the fact is detected.

A changed output byte, a forged hash, or a lost output. This is hash comparison, not re-execution, and it is not offered as E2.

E4 · A refusal is itself a signed record with its reason.

The Substrate refuses an inadmissible request, and the refusal is recorded like any other run.

E5 · No model is loaded or called in governed operation.

The kit ships the result of that check and the sha256 of the instruments that produced it, not their source. This item is a result, not a check you can re-run here.

E6 · Each link from intent to output is hash-bound and recomputes offline.

Each run ships with its submitted intent beside it, because the record carries the intent's hash and not the intent.

GOVERNED OPERATION · NO MODEL LOADED OR CALLED (E5) Intent as submitted hash admissible? yes Sealed plan id from six inputs body under the seal's hash Output its hash recorded no Refused a signed record, with its reason recorded like any other run Kernel export signed payload bytes · form hashes bodies named · intent as submitted read offline Boundry Verify recomputes the plan id · walks each link · compares runs by hash · gives a verdict
Intent as submitted its hash goes into the record GOVERNED OPERATION no model loaded or called (E5) admissible? no Refused a signed record, with its reason yes Sealed plan id from six inputs body under the seal's hash Output its hash recorded recorded like any other run Kernel export signed payload bytes form hashes · the bodies it names the intent as submitted read offline, on your machine Boundry Verify recomputes the plan id · walks each link compares runs by hash · gives a verdict scope: records in the evaluation kit
D3 · One request, traced. Intent, admissibility, sealed plan, output, kernel export, and the verifier reading the export offline. A refused request ends in a kernel export too. The scope is the records in the evaluation kit.

Try it

The evaluation kit, in three prompts.

The package ships evidence from real governed runs of the Boundry Substrate: one calculation, the smallest real transformation chain, and one refused request, each run on both platforms. Three tampered copies of one export sit beside them, and one verifying key. The inputs are synthetic.

1

Have Python 3.12 or newer.

The package declares the floor and enforces it: below 3.12 it refuses before doing any work, naming the floor and the version it found. The Python that ships with macOS is older; install a current one from python.org or your package manager.

2

Download the .mcpb from Releases and open it with Claude Desktop.

The .mcpb is a zip file. The code, the documents and the check command are inside it. On the install screen, leave “Folders the connector may read” empty to use the packaged kit; a folder entered there replaces it.

3

Ask about the packaged folders by name.

Every tool takes corpus_dir, and it takes a name. With nothing configured, kit is the evaluation kit and demo the demonstration records, so the first call works before anything is set up. A folder you declare as label=path answers to its label; a bare path answers to its path. An undeclared label is refused, and no path is shown.

“Use Boundry Verify to compare runs calculation-m2 and calculation-linux-aarch64 in the kit, global scope.”

You should see EQUIVALENT. The answer names each field that differs and marks every one as expected, with the reason: the wall-clock stamps, the hashes taken over them, each run's environment (its interpreter, operating system, machine and packages), the platform that ran it, and the run's own label. Nothing else differs.

“Compare calculation-m2 with calculation-m2--forged-hash in the kit, global scope.”

You should see DIVERGENT: the forged hash is caught for what was done to it, by hash comparison, not re-execution.

“Explain record transformation-m2 in the kit, global scope.”

You should see the export's lineage link by link, from submitted intent to output, each link recomputed offline.

The repository is also a plugin for Cowork and Claude Code. It runs the same server and reads only the packaged folders, kit and demo.

Then run the package's own checks from its unpacked folder:

python3 -I -B -m unittest discover -s server/boundry_connector -t server

Standard library only: no test framework to fetch, no network, no configuration. Expect 0 failures and 0 skipped. Running them does not alter the package; its tree digest is the same before and after.

Whatever the connector reads is returned to Claude as part of your conversation. The connector sends nothing itself; the conversation is another matter. Read the privacy policy before you point it at anything that is not synthetic.

Questions a reviewer asks

FAQ

What is Boundry?

Boundry is the architecture. Its centre is the Boundry Substrate, which performs governed execution and leaves a signed kernel export for each run. On the governed road an inadmissible request is refused and the refusal is recorded (E4); an admissible one becomes a sealed plan whose identity is a function of its inputs (E1); execution is deterministic (E2); and no model is loaded or called (E5).

Boundry Verify is the verifier for that architecture, not the architecture: a separate package that reads the records and checks them. It reaches none of the Substrate's declared dependencies, and its own import chain is standard library only. The Substrate itself does not ship here.

Does this make AI safe?

It changes where the danger sits. Much of the concern about AI is about what it might do. In Boundry, a model does not do anything. It proposes. Whether the work runs is decided by the Substrate, which also carries it out, with no model loaded or called (E5). When a request is refused, the refusal is a signed record with its reason (E4). Anything else the model tries is a new request, and it is checked the same way.

Put simply: the AI can be the brain, and Boundry is the hands. The hands are designed to move only under rules declared by the people who run Boundry, never by the model. The question stops being “what will the model do?” and becomes “what do our rules say?”, and every answer is on the record.

What this does not cover: a rule can still be wrong; work that reaches the world by some other route is outside the Substrate; and the kit shows the refusal side today (E4), not yet a declared rule set being enforced.

Is the model ever in control?

In governed operation, no model is loaded or called (E5). The kit ships the result of that check and the sha256 of the instruments that produced it, not their source, so it is a result you read rather than a check you re-run here.

Outside governed operation, in your Claude Desktop conversation, a model reads whatever the verifier's tools return. That is the point of the connector, and why the privacy policy says your conversation is not private.

What happens when something is refused?

The Substrate refuses an inadmissible request, and the refusal is itself a signed record with its reason (E4). The kit's three workloads include one refused request, run on both platforms.

The verifier refuses too, for named reasons: a read with no declared tenant scope, a folder you have not declared, a link whose final target is outside a declared root. A refusal never renders a path.

Refusal is an outcome, not an error. It is recorded like any other run.
What can the verifier see or change?

It reads sealed records from folders you name, and nothing else; with nothing configured, that is the two packaged synthetic folders. It cannot sign, writes nothing, subscribes to nothing and attaches to no database. Where it compares, it compares hashes, not re-executions.

The verifier cannot sign, writes nothing, and has no write tool. Each is held by a named check with a planted control it must reject.
Does it need the internet?

No. It opens no socket and contacts no endpoint, and nothing in its checks depends on the network. It depends on nothing outside Python's standard library: importing the package pulls in zero third-party distributions, measured rather than recalled.

What does “offline verification” actually check?

For a record in the kit: that a sealed plan's id recomputes from its six inputs and its seal checks (E1); that each link from intent to output recomputes (E6); that two runs are equivalent or divergent field by field, by hash (E2, E3); and that a refusal is a signed record with its reason (E4). It checks against the verifying key in the kit, and it does not re-execute.

What doesn't it show?

The README's ceiling: one key signs everything and you hold it; the determinism shown is for the governed road, on the workloads in the kit, across the platforms named. A valid signature shows that key signed the record and that it has not changed since; it does not show that anyone independent saw it happen.

So: synthetic inputs; one verifying key; E2 on three workloads and two platforms; E3 by hash comparison, not re-execution; E5 a result, not a re-runnable check; and a conversation that is not private. The full list is beside What can be established.

Where is the technical evidence?

In the README, which names a check for each claim on a Held by line, and inside the .mcpb, which carries the code and the checks. If your measurement disagrees with this page, the measurement wins; verify@boundry.tech is where to say so.

Technical evidence

The README is the evidence document. This page is the map to it.

Every claim this page makes about the system is one the README makes, and the README names the check that holds it. Some of those checks, as the README names them:

it_opens_no_socket_and_contacts_no_endpoint it_cannot_sign it_neither_writes_nor_subscribes it_attaches_to_no_database there_is_no_write_tool_and_no_disabled_one every_tool_declares_a_title_and_the_four_hints a_read_with_no_declared_scope_REFUSES_and_is_not_widened a_folder_you_have_not_declared_is_refused_for_THAT a_refusal_never_echoes_the_path_you_named E1_each_sealed_plan_recomputes_its_id_and_its_seal E2_the_same_request_on_each_platform_is_EQUIVALENT E3_each_tampered_copy_is_caught_for_what_was_done_to_it E4_the_refusal_is_a_signed_record_with_its_reason E5_the_conduct_line_result_ships_with_its_instruments_digests E6_each_run_walks_link_by_link the_package_carries_verifying_keys_and_no_secret no_document_makes_a_claim_the_code_does_not_hold

Read the README on GitHub

For the design, threat model and evaluation, see the preprint and research notes at github.com/Boundryos/research.

Free to use; not open source. You may install and use the package unmodified, including to evaluate it and to verify records with it. The licence ships beside the README as LICENSE.txt.