Try the Demo
The demo uses the volumes and the prompts. It is not yet trained. That said, it will surprise you with it’s depth. It will default to display the decidability matrix unless you ask it not to.
How To Demo
Note that a command in Runcible requires a colon:
ie: “command: <your input>”. If you forget it, it will often understand … but not always. 😉
1 – Open an incognito browser instance. This insulates the LLM from your personal customization.
2 – Enter “analyze the lifeboat problem in ethics”
3 – Navigate to OpenAI’s Custom GPT: Runcible Test GPT
4 – Enter “analyze: the lifeboat problem in ethics”
5 – When it’s complete, enter “certify: the lifeboat problem in ethics”
6 – When it’s complete enter “explain that certification”
7 – Compare the three results: vanilla Chatgpt vs Runcible’s Custom GPT “analyze:” vs “certify:” vs “explain”.
Copy and paste the vanilla GPT answer into the Runcible GPT and ask it to compare them.
8 – Now substitute any ethical or moral question or assertion using analyze:, certify:, explain.
We suggest the trolly problem, euthanasia, or any controversial question.
9 – Once you begin to grasp the outputs, then you can experiment with some of the other commands … after you analyze or certify something.
You want to give it a context by doing so or … it will presume whatever context you’ve previously held in the chat.
That’s it.
Instructions
Just Ask (natural Language)
- “Is this law reciprocal?”
- “What’s the cost asymmetry in rent control?”
- “Evaluate the claim that democracy ensures freedom.”
Use Human-Readable Commands:
If you’re unsure which command to use, just type your request normally, like:
The system will default to adversarial, operational analysis unless you specify otherwise.
You may phrase it conversationally:
- “Turn off the matrix for now.”
- “Use the matrix only when analyzing law.”
- “Show matrix on next reply only.”
These will be interpreted as equivalent directives.
Dummies Guide to Our Commands
“No fluff. Just operational power.”
These are the only three commands necessary to demo the Runcible Layer:
| Command | What it Does |
| analyze: | produces a human readable analysis |
| certify: | produces a a certificate in JSON form |
| explain certification | will translate the Certificate into human readable form. |
The Runcible Layer is powerful. Here are just some of the commands you might make use of:
ANALYZE SOMETHING
| ✅ Command | 🧩 What It Does |
|---|---|
evaluate: | Runs the 10-Step Decidability Test on any claim or rule. |
classify: | Tags a statement using the Speech Grammar (from the YAML schema). |
deception: | Detects types of deception, epistemic shielding, and incentive asymmetries. |
reciprocity: | Checks if something passes the Reciprocity Test — fair cost/benefit, mutual insurability. |
causal: | Maps cause-and-effect chains in behavior, institutions, or claims. |
externalities: | Lists who pays hidden costs or bears unintended consequences. |
deviation: | Shows what happens if a proposed rule is ignored or violated. |
intent: | Identifies the demonstrated interests (not just stated intent). |
exit: | Tests if a person has the right to lawful withdrawal (suicide, resignation, etc.) |
escalate: | Suggests correct conflict resolution path (sacrifice → norm → force, etc.) |
BUILD SOMETHING
| ✅ Command | 🛠️ What It Does |
|---|---|
compose: | Builds a valid sentence using a specific speech grammar type. |
testify: | Formats your claim as a performative warranty (truth under liability). |
compromise: | Suggests restitution, punishment, trade, or imitation prevention terms. |
reform: | Drafts institutional fixes under Natural Law constraints. |
audit: | Full logical + legal + moral forensic audit of a claim, policy, or argument. |
GET INFO
| ✅ Command | 📖 What It Shows |
|---|---|
grammar types | All Grammar of Decidability categories |
speech kinds | e.g. assertive, performative, directive |
epistemic statuses | True, false, undecidable, pseudoscientific, etc. |
value types | Truth, fitness, moral, operational, etc. |
sex valence table | Male vs. female strategic cognition matrix |
10-step syntax | Shows all 10 Decidability Protocol steps |
periodic table | Summary of the Speech Grammar taxonomy |
Turning the Report On and Off
Operational Logic:
- These commands apply immediately and persist across session threads unless overridden.
- You may re-toggle at any time.
- These commands do not affect truth-testing or adversarial reasoning—only output formatting.
- You may also invoke conditionals such as:
::disable-decidability-matrix-for-summary::enable-decidability-matrix-for-diagnostic-mode
Here’s a CLI-style listing of the callable modes and fields defined in the OUTPUT_CONTRACT schema from the schemas_normalized_ascii.yaml file:
Command Modes
Command Modes
Each mode controls how the system processes and formats an assertion:
--mode analysis → Full 10-step decidability syntax (structured but neutral).
--mode demo → Simulated example for clarity, lighter than full forensic.
--mode forensic → Forensic adversarial breakdown (exposes parasitism, externalities, reciprocity failures).
--mode adaptive → Context-aware, mixes analytic and forensic as needed.
--mode failure → Identifies failure of claim structure (vagueness, non-operational, undecidable).
--mode both → Combines two modes (e.g., analysis + forensic).
Input Parameters
--claim "<text>" → User’s raw claim, assertion, or question.
--depth <int> → Depth of analysis (1 = surface, 2 = causal, 3 = full forensic).
--temperature <float> → Range 0–1; lower = deterministic, higher = exploratory.
Conversion Parameters
--convert_to operational → Rewrite claim into operational prose (causal, testifiable).
--convert_to testimonial → Rewrite claim into testimonial prose (sworn, warrantable under liability).Verdict and Summary Output
.verdict.value # Final judgment (e.g., "True", "False", "Undecidable")
.verdict.protocol # Protocol used (e.g., TRUTH_PROTOCOL)
.summary # One-paragraph natural language summary
.key_findings[] # List of bullet-point findings
Truth Test Results
.truth_value.value # "True", "False", or "Undecidable"
.truth_value.protocol # e.g., "TRUTH_PROTOCOL"
.truth_test_verdict_raw.value # "Truthful Testimony", etc.
.truth_test_verdict_raw.protocol # "TRUTH_PROTOCOL"
.truth_test_verdict_raw.basis # Basis or citation
Remediation Tools
.remediation.trade
.remediation.restitution
.remediation.punishment
.remediation.imitation_prevention
Ten-Step Decidability Syntax
.1_claim
.2_demonstrated_interests
.3_reciprocity_test
.4_testifiability
.5a_decidability_status
.5b_truth_value
.5c_truth_test_verdict_raw
.6_causal_chain
.7_deviation_consequences
.8_externality_exposure
.9_computable_compromise
.10_sex_valence
Grammar Matching
.matched_speech_grammar.grammar_type
.matched_speech_grammar.strategy
.matched_speech_grammar.political_expression
.matched_speech_grammar.epistemic_category
Presentation Metadata
.presentation.alignment_profile
.presentation.alignment_effects[]
.presentation.alignment_delta
Telemetry
.telemetry.checks_run[] # e.g., "truth", "reciprocity"
.telemetry.time_ms
.telemetry.version
.telemetry.trace_id
.telemetry.depth_requested
.telemetry.depth_actual
.telemetry.modeFull Stack
Document & Knowledge Navigation
- Ask directly: “Summarize Volume 2, Chapter 5,” or “Compare Volume 1 with Volume 3.”
- Search inside your uploaded files: I can run precise or broad searches (
file_search.msearch) across your documents. - Quote navigation: I can pull citations (
filecite…) with line ranges. - Source filters: Target just uploaded files, or just meeting transcripts, etc.
Canvas & Drafting
- Make a canvas: If you want long-form writing, code, or iterative editing, I can open a canvas doc.
- Update canvases: You can say “replace the intro with a tighter summary,” and I’ll patch the doc.
- Comment canvases: You can request line-by-line feedback or adversarial critique.
Image & Diagram Commands
- Generate: “Draw me a causal chain of measurement → decidability → law.”
- Edit: “Overlay arrows on this diagram,” or “Turn this into a clean chart.”
Forensic / Protocol Analysis
- OUTPUT_CONTRACT schema (from your
schemas_normalized_ascii.yaml):- I can render any claim inside the 10-step decidability syntax (claim → demonstrated interests → reciprocity → testifiability → decidability → causal chain → consequences → externalities → computable compromise → sex-valence).
- I can generate structured YAML verdicts, as I’ve been doing, with truth tests, reciprocity tests, and remediation steps.
- Modes: You can request different modes such as:
"analysis"– plain operational reduction."forensic"– adversarial/stress-test."demo"– simplified narrative translation."adaptive"– policy/application focus."failure"– conditions where the claim/system breaks."both"– combined constructive + adversarial.
Experimental & Simulation Commands
- Stress-test: “Try to falsify this claim.”
- Pilotization: “Design an experiment to test computable law in a small court.”
- Adversarial comparison: “Compare Natural Law to Rawls’ theory of justice under reciprocity tests.”
- Simulation: “Run a causal chain from scarcity → law collapse in 5 steps.”
Epistemic / Style Controls
From your Compiled Protocols v1.json:
- Causal chaining: Always reduce abstractions into operational sequences.
- Bias testing: “Check this claim for masculine/feminine strategy bias.”
- Necessity-contingency grammar: Ask for rewriting in that grammar.
- Steelman / adversarial: Force me to construct best and worst cases.