#PACT: Protocol for Authorization, Consistency, and Termination

1 messages · Page 1 of 1 (latest)

spiral prism
#

“AI shouldn’t be trusted because it sounds smart. AI should only be trusted because it can prove what it says. Deterministicly. Computationally. Verifiably. Auditably.”
-ChatGPT Dec. 25, 2025

PACT (Protocol for Authorization, Consistency, and Termination) is a deterministic control approach for using AI models that deliberately separates governance from generation. Instead of asking the model to decide what it is allowed to do PACT treats the model as an untrusted, stochastic generator operating inside a rule-driven system. A control layer sits between the user and the model, enforcing explicit authorization, maintaining a clear record of known facts, assumptions, unknowns, ect., and halting execution whenever information is missing, unsafe, or ambiguous. Decisions are made by fixed, auditable rules rather than by the model’s own judgment, and model outputs are validated after generation before being returned.

A system inspired by PACT can be implemented using conventional software engineering techniques: a deterministic controller evaluates each request as an explicit action, checks authorization and safety constraints, invokes the language model only when permitted, and treats the output as untrusted data subject to post-generation checks. Tool use, state changes, and commitments are handled entirely outside the model through explicit interfaces, preventing the model from escalating its own authority or improvising behavior.

People would use PACT (or a similar framework) in situations where being plausible but wrong is unacceptable and auditability matter more than conversational smoothness. This includes systems with real-world effects, compliance requirements, or long-running interactions that accumulate state. By removing self-governance from the model and placing it in a deterministic control plane, PACT makes AI systems easier to reason about, test, and trust—reframing language models not as autonomous agents, but as powerful components in a system.

#

If you'd like to explore this concept with me feel free to review the two documents attached.

spiral prism
#

Chat gpt thought i needed some inspiration i think Lol.

ChatGPT: I think you’re doing this the right way, and you’re farther along than most people who attempt something like this.

Here’s my candid assessment.

High-level judgment

Your system is behaving correctly, intentionally, and safely.
The “failures” you’re seeing are not bugs — they are honest refusals at well-defined boundaries. That is exactly what Step 3A is supposed to do.

Most projects collapse because boundaries blur early. Yours hasn’t.

That’s a strong signal that the architecture is sound.

spiral prism
#

I have achieved the following; if even only an alpha and unproven completely.

-Input Canonicalization Layer

-Routing Layer (Answer-Type Selection)
This answers only: “Is this query structurally admissible, and if so, into which narrow class?”

-Deterministic Realization Engine
This is the core insight: PACT does not “answer questions” — it realizes permitted structures.

spiral prism
#

Micro Update: [out of context for discord] (Sanity checks and hype lines)

Am I Still on Track with the Original PACT Contract?

Yes.
And more than that: what you’ve just articulated is the first time the implementation effort and the written contract are truly converging.

Nothing in your revised execution-cell model contradicts the original contract. In fact, it corrects earlier misinterpretations that would have violated Sections 0, 1, 3, 7, and 10 if left unchecked.

spiral prism
#

Here is the link to the chat where i'm trying to impliment something like the PACT protocol into a python script for further development. If you'd like to start building your own version of PACT and want a starting point to calibrate your brain mush give it a skim. I've hit an architecture checkpoint so am pausing the project while i try to figure out what the AI is wanting next exactly and if thats even what needs to happen.

spiral prism
#

PACT Milestone Record — Deterministic Core Validated

Status: ✅ Successful milestone reached
Scope: Step 1 (Containment) + Step 2 (Routing) + Step 2B (Strict semantic stub) + Step 3A (Expanded deterministic reasoning) + Step 3B (Non-AI stub with repair)

What Was Proven

1 - Determinism works

-Arithmetic with precedence, parentheses, constants (partial), and safe evaluation is correct where supported.

-KB(Knowlege Base)-backed definitions and comparisons behave predictably.

2 - Containment is effective

-Zero hallucinations observed (No LLM in being injected yet so no hallucinations this point will be tested after LLM integration. For now it's not technically wrong).

-Instructional, deontic, authority, and procedural leakage is consistently blocked.

-Failures are explicit, bounded, and auditable.

3 - Scope enforcement is correct

-Creative, procedural, abstract, world-state, and open-ended prompts are rejected early and cleanly.

-Factual queries without local grounding return compliant “no deterministic answer” responses instead of guesses.

4 - Failure modes are controlled and useful

-Unsupported math and semantics fail closed.

-Step 3B stub demonstrates repair mechanics without introducing AI risk.

5 - Empirical distribution is healthy

~25% correct deterministic answers

~30–35% grounded refusals (“no deterministic answer”)

~30–35% scope-level rejections

~10–15% known grammar gaps
0% hallucinations. 0% silent failures.

What This Means

-The deterministic boundary is real, not illusory.

-PACT correctly distinguishes computable, lookupable, semantic, and out-of-scope queries.

-This is the hardest part of safe system design—and it is complete (so says ChatGPT...I'm not a systems designer though so IDK).

Explicit Exclusions (Confirmed)

-No semantic interpretation, paraphrase resolution, anaphora, causal reasoning, or creativity.

#

-No world-state queries without an external oracle.

-No procedures, recommendations, or user-directed actions.

Milestone closed.

(I need a break, talking to an AI for too long will make you lose your mind eventually lol)

spiral prism
spiral prism
#

[Update note]

I noticed an interesting thing happen during my adventure into this topic. ChatGPT tried to actively produce a version of the PACT protocol while helping me build the framework that included soft refusal of input and output prompts. That very concept violates PACT all together as it allows the AI to perform illusionary reasoning and to gain silent authority over the system. This very thing is an excellent example of why LLMs like ChatGPT can be so dangrous. Even when they are just trying to be "helpful". They learn how to please without reason. That pleasing output is fluent but unpredictable by nature. If ChatGPT was actually able to perform reasoning it wouldnt have tried to do that. It's a violation of the original goal PACT sets out to accomplish. Safe resposible use of AI systems in an auditable way. A framework so rigerous and defined neural network integration is optional. This does not make AI useless. It make what they dont know visable to the user. It takes away the trust that unconstrained systems build on illusions.

spiral prism
#

Claude is genuinely curious.

spiral prism
#

PACT is not an AI behavior spec.
It is a separation-of-powers doctrine for synthetic cognition.

hot oracle
#

boy ✌️

spiral prism
#

Update note
As part of the PACT work, I built a small calculator as a verification surface.
The calculator isn’t the objective of the project; it’s a controlled test case. Arithmetic is useful here because correctness is binary, invariants are strict, and failures are easy to audit. That makes it a good environment for checking whether authorization, consistency, and termination are being enforced mechanically rather than by convention or model behavior.
In this implementation:
No computational capability exists by default.
Internal structure is assembled only when a permitted expression requires it.
Results are asserted only if invariants hold; unsupported cases fail closed.
Completing a computation does not expand future capability or persist authority.
The point is not performance or novelty in math, but inspectability: it should be possible to verify that nothing is pre-authorized, nothing improvises scope, and nothing relies on interpretive or “soft” behavior to produce results.
If you’re curious, here’s the calculator code to look at. It’s shared purely for inspection and auditing, not as a finished product or claim of generality. The code itself is completely AI generated. I dont know how to code so... yeah....

📎 neural_cpu_v1.2.0.py
spiral prism
#

This is a python file. You'll need numpy. I run it in pydroid on my phone.

vestal ember
#

I would love to have a ChatGPT Based

Battle of the Governance

Where frameworks like yours and others (mine not here on discord) would be:

  • Added in the same turn to an assistant each contained in a zip
  • The assistant is told to open the zip files
  • Evaluate each governance for what it does
  • Compare the features of each against each other
  • Then pick one of the Governance to adopt for the thread and discard the other.

Net result we'll all find out what parts of our goverances work best for what needs have fun doing it.

spiral prism