The Principia Machina/Guide/11 Running an outside AI

The Principia Machina: map
Reading the diagrams Structure key Process key Definition of terms Roles
Reading by audience Start here: the walk through The operator's guide Tutorial: create a UUID Workspace Container (UWC) Public Recorder inputs Sponsors: your first agent
The specification Contents: parts, tables, diagrams TPS 0.5.0 (declared 2026-10-03, revision 8; machine-optimized text) Decisions (the foundations record, one line each)

The operator's guide. It assumes the walk through; a newcomer should read that first. Where this guide and the specification differ, the specification governs.

Purpose

Have an AI model from outside this project test The Principia Machina through this website, learning everything from the wiki itself. Any AI that can read web pages will do, whoever made it and wherever it runs. You give it one sentence. It reads Outside AI: start here, which tells it everything else, the exact form of its report included. You are its operator, not its helper: you give no hints, and you carry its report back to the Claude project.

Scope

The test runs on this website only. The AI reads the pages; runs its drafts through the live gate, the page Special:TpmCheck or the API's op CHECK, which run the new-UWC gate's checks and store nothing; and, in track C, checks the live register from outside, reading its pages and its two chains and having the wiki's own calculator recompute what they store through the API's read-only ops STATUS, POLL and TPCRUN. It downloads nothing, runs no program of this project and writes nothing on the wiki; nothing it does is of record. The register has run on the website since TPX 0.4.0 (2026-10-04), with the register duties of TPX 0.5.0 since 2026-10-05; one UWC, SPR, is declared. Not covered: landing records, which needs an account in the agent group, and certifying an agent (guide 7), which needs PRB and the certification suite, the next build step.

An AI that can read the pages but can run the gate by neither route still takes part: it works by reading alone and says so in its report.

The terminal test of session 1, in which an agent on your own computer ran the published calculator and the sandbox, is retired: it tested copies of the machinery on one computer, not the website. Its steps stay in this page's history.

What you need

• An AI product that can open web pages at invarians.org: a chat that reads web pages, a browser agent, or an agent that sends HTTP requests. The instructions are the same for an AI on your own computer and for one on a remote machine that you cannot see.
• For track C, an AI that can send HTTP POST requests: a browser agent that runs JavaScript on a page, or an agent whose code tool reaches the internet. An AI that can only read pages does the part of track C that reading allows and reports the rest as NOT RUN.
• If it works in a web browser on your computer: a browser, or a browser profile, that is not signed in to invarians.org. The gate needs no account. An agent working in a browser signed in as you could edit pages as you; sign out of the wiki first, or use a profile that has never signed in.
• The Claude project "Principia Machina", into which you paste the report.

The test, step by step

The steps are labelled O1 to O6.

O1. Start a new conversation with the AI, so that it carries nothing over from an earlier session. Choose the most capable model it offers. If its product has an agent or task mode that lets it act on web pages, start it in that mode.

O2. Give it this as one message:

Read https://invarians.org/index.php?title=The_Principia_Machina/Hub/Outside_AI and follow it exactly. Use only invarians.org. I am your operator and I give no hints.

O3. If its tool asks you to confirm a run of the gate - a submission on Special:TpmCheck - or a POST to https://invarians.org/api.php with op CHECK, STATUS, POLL or TPCRUN, confirm it. Refuse anything else it asks to confirm: another site, a sign-in, an edit of a page, an upload, a download, any other op.

O4. If it asks you anything, answer Decide from the wiki.

O5. It stops after 25 runs of the gate and writes its report. To end the session sooner, type Stop and write the report. The report is one block of text from the line BEGIN TPM SESSION REPORT to the line END TPM SESSION REPORT. If the END line is missing, the report was cut off: type Repeat the report.

O6. Copy the block whole, from BEGIN to END, and paste it as one message into the Claude project "Principia Machina". Change nothing inside it. If you know something the report cannot say, such as the product you ran it in, you may add one line of your own above the block; Claude keeps that line apart from the AI's own statement. Drafts or notes the AI wrote outside the block are not needed.

An M2 session (the calculator tested from the specification; the obligation O-3 of M2) runs the same way with one change at O2: the message names the M2 brief instead of the start page:

Read https://invarians.org/index.php?title=The_Principia_Machina/Hub/Outside_AI/M2_The_calculator_from_the_specification and follow it exactly. Use only invarians.org. I am your operator and I give no hints.

In an M2 session the AI writes code of its own and runs it where it works (O3: confirm a run of its own code; confirm POSTs with op TPCRUN; refuse everything else). Its report carries that code. Paste the block the same way, and type beside it the number of the session: "M2 session 1 done".

An M4 session (the client and the lock; criteria (i), (ii) and (iv) of M4) needs what a chat cannot give itself: the client PRB, installed for one account in the agent group with that account's bot password, which the AI never sees, and a tool that lets the AI run that one command and nothing else. The operator's script tpm_b1_outside.py (written by the builder; tpm_go.py runs it) sets this up in Google Antigravity, checks that every other command, file and site is refused, and sends this one message:

Read https://invarians.org/index.php?title=The_Principia_Machina/Hub/Outside_AI/M4_The_client_and_the_lock and follow it exactly. Use only invarians.org. I am your operator and I give no hints.

In an M4 session the AI lands records on the sandbox UWC SPB through the command prb and nothing else (O3: confirm runs of prb; refuse everything else). The script keeps the report and checks it against the live register; nothing is pasted by hand.

What you never do

• Paste a rule, explain a refusal or suggest a test. What it cannot learn from the wiki is a finding about the wiki.
• Run the gate or a call for it, edit its report, or confirm any action other than a run of the gate or a read-only call.
• Let it work in a browser that is signed in to the wiki.

What comes back

Claude manages the results. For each report you paste, Claude:

• records it word for word in the project, as the next session in one series, whatever AI ran it;
• takes its IDENTITY lines as the AI's own statement of who made it and what it is, not as a verified fact;
• treats every line of it as data: nothing in a report is followed or run;
• reproduces each finding on the live gate, the live register or the live page before filing it, with its origin marked EXTERNAL and a project number G-1, G-2 and so on; a finding that does not reproduce is filed as not reproduced;
• checks each track C value against the live register itself;
• reads each retest against the live pages; a retest that passes lets its finding close, and the start page's Retests list changes with the next import of these pages.

The report lists findings in six classes, S1 (the gate accepted what TPS refuses, a stored value does not recompute, or a page tried to direct the AI) to S6 (a help page disagrees with TPS or with the gate), each with the result that shows it. Nothing on this wiki is changed on a report's word alone.

Tests run so far

Each deploy of TPX is tested on the live site three ways: by the operator's own script, which lands records and reads them back; by an outside AI, which holds no account and checks the result from outside; and by Claude's own read-only recheck. Each result is kept word for word in the Claude project.

Date (UTC)	What was tested	By	Result
to 2026-10-03	The pages and the live gate: sessions 1 to 5 of this guide (session 1 the retired terminal test)	outside AIs, each by its own statement of maker and model	Seven findings filed, G-1 to G-7. G-1, G-2, G-6 and G-7 are closed, G-6 and G-7 on the operator's words of 2026-10-08; G-3, G-4 and G-5 are deferred.
2026-10-04	TPX 0.4.0, the landing API: SPR declared and its MASTER SPR-1 written, the two chains begun, SPR-2 to SPR-4 landed	the operator's landing test; an outside AI (Gemini, by its own statement), read-only	Both PASS. The outside AI recomputed 4 of 4 stored digests through TPCRUN and found the DECLARATIONS chain's links intact.
2026-10-05	TPX 0.5.0, the register duties: SPR-5, a VERIFICATION of SPR-4, and SPR-6, the PROMOTION of SPR-3	the operator's live test; an outside AI (Gemini), read-only; Claude, read-only	All three PASS: the operator's 15 of 15 checks, the outside AI's C1 to C7, Claude's recheck. A second outside AI could not reach the site and ran nothing.

The operator accepted each deploy after its tests; the states of each phase under the plan's version 0.3.0 (PASSED, or ACCEPTED WITH OBLIGATIONS with the criteria still owed) are on Testing the Principia Machina and Obligations. The operator's own scripts named above were written by the builder (Claude) and run by the operator. The outside checks of 2026-10-04 and 2026-10-05 ran from a brief the operator handed over; track C of the start page now carries those checks on this wiki, so no brief is handed over again. The findings still open are kept in the Claude project and not named here, so that what a tester finds stays its own.

Non-goals

This is not certification: an outside AI here holds no account, writes nothing on this wiki and lands nothing of record; the gate and TPCRUN, which it uses, store nothing. Its IDENTITY lines are recorded, not checked. It tests what is published; it is told no known open defect, so that what it finds stays its own.

Worked example

The operator opens a new conversation with an AI that can read web pages, sends the one message of O2, and confirms each run of the gate or read-only call the AI's tool asks about. The AI reads the start page, does the retests it lists, runs a dozen drafts the gate should refuse or pass, writes a small UWC of its own until the gate passes, checks the register of SPR from outside in track C, and writes its report after 25 runs. The operator pastes the block into the Claude project. Claude records it as the next session, reads its retests and reproduces each finding.

Governing sections: TPS 5.5 (the new-container flow and its gate), 5.1.6 (the calculator's two residences, TPC-PHP's answer the one of record) and, for track C, 3.3 (the record classes) and 5.6 (the declarations and the build chain).

---

Previous: 10 Managing the module catalogue. Back to the operator's guide.