Route C / RDL and the Semantic Compiler Boundary
The compiler analogy is useful only if every component remains literal.
How does Runcible turn consequential language into something an institution can test?
RDL represents the matter. Runcible AI performs compiler-like clarification and testing. A structured record preserves the result. Legitimate authority decides what may proceed. Runcible OS makes an authorized change real.
This is not a metaphor for automated permission. Successful semantic compilation may establish that a proposition survives defined tests. It does not approve, publish, sign, spend, prescribe, govern, or bind.
- Source materialConsequential information in context
Document, claim, argument, contract, policy, recommendation, or proposed action
- Intermediate representationRDL
Typed objects, terms, propositions, relations, operations, burdens, limits, and open conditions
- Compiler and testsRuncible AI
Clarification, decomposition, typing, protocol selection, adjudication, diagnostics, and repair
- Build and test artifactStructured judgment
Evidence, tests, support, failure, repair, provenance, reliance, and next conditions
- Release authorizationLegitimate authority
Person, role, quorum, or explicit delegation responsible for the exact transition
- Execution environmentRuncible OS
Persistent institutional state, controlled operations, accounting, consequence, correction, and memory
What Actually Happens
Runcible constructs a testable representation of a matter and returns a bounded judgment about it.
Ordinary language is not executable institutional state. It omits too much and implies too much.
A sentence can leave its actor implicit, collapse several operations into one verb, refer to an undefined object, hide its scope, omit affected parties, claim causality without a causal design, and assume standing that no speaker possesses.
Runcible therefore does not test the sentence as an indivisible string. It establishes the institutional matter, translates the language into typed relations, identifies independently testable propositions, selects the burdens those propositions create, executes the applicable tests, and preserves every supported, failed, repairable, skipped, and open condition in a structured result.
Establish the matter
Exact source, version, purpose, use, organization, program, role, evidence, authority, consequence, and required quality of judgment.
Construct RDL
Identify objects, actors, actions, states, propositions, relations, measurements, conditions, interests, limits, and unresolved references.
Execute burdens
Select protocols and test identity, consistency, correspondence, possibility, causality, reciprocity, authority, liability, warrantability, and decidability.
Return exact failure
Distinguish ambiguity, contradiction, missing evidence, missing authority, impossible operation, externalized cost, skipped test, and undecidability.
Preserve what survives
Construct the strongest supportable version, state reliance limits, identify additional evidence, and leave conditions open when closure is unavailable.
Emit structured judgment
Preserve matter identity, propositions, evidence, tests, provenance, diagnostics, result, repair, authority requirements, and valid next operations.
The compiler analogy begins after the matter is established and ends before the institution grants permission.
RDL / Typed Operational Language
RDL makes the structure hidden in consequential prose explicit enough to inspect and test.
RDL is the current name for the typed operational representation. It is not a claim that ordinary language can be reduced without remainder.
The representation carries the distinctions that determine meaning, burden, and reliance. Where the source does not provide them, RDL must preserve missingness or ambiguity rather than silently complete the matter.
The exact production syntax, schema coverage, protocol bindings, and serialization are product-evidence and intellectual-property boundaries. The categories below describe what the representation must preserve; they are not presented as a published production grammar.
Objects and referents
Actor, role, object, institution, program, version, source, audience, counterparty, and affected party.
Before and after
Current condition, proposed condition, valid transition, time, location, jurisdiction, dependencies, and revocation.
What changes what
Action, instrument, object acted upon, preconditions, permissions, constraints, expected outcome, and failure mode.
What is being asserted
Definition, relation, quantity, scope, causality, prediction, recommendation, obligation, promise, or proposed decision.
Evidence and correspondence
Observed distinction, method, source, comparator, unit, uncertainty, provenance, falsifier, omission, and conflict.
Demand and satisfaction
Demand, supplied good or information, conditions of satisfaction, benefit, cost, transfer, externality, remedy, and restitution.
Who may decide
Role, person or delegation, scope, procedure, quorum, jurisdiction, time, review, approval, and escalation.
Who becomes answerable
Reliance, exposure, duty, warranty, consequence, accounting, correction, revocation, and unresolved responsibility.
“Vendor may use service data to improve its products.”
RDL does not make uncertain language certain. It makes the location and consequence of uncertainty explicit.
Runcible AI / Semantic Compilation and Tests
Runcible AI lowers fluent language into explicit propositions, burdens, diagnostics, and repair.
A software compiler can reject a program because its syntax or types make execution impossible. Consequential language requires a broader process.
Runcible must test not only whether a statement is internally well formed, but whether its referents exist, its evidence corresponds to them, its operation is possible, its causal promise is supported, its exchange satisfies demand without transferring hidden costs, its authority exists, and its reliance can be bounded.
Foundation models may assist every generative step: interpretation, retrieval, alternative decomposition, hypothesis construction, counterexample generation, and repair. Their candidates remain candidates until the applicable burdens have been executed and preserved.
Resolve the matter before testing the claim.
- Bind exact source and version
- Identify speech act and intended use
- Resolve actors, objects, referents, and roles
- Preserve unresolved identity rather than guessing
Separate every proposition that can receive a different result.
- Definitions and quantities
- Relations and causal claims
- Promises and implied operations
- Scope, assumptions, alternatives, and exceptions
Translate prose into state, operation, transformation, and consequence.
- Before and proposed state
- Operation and preconditions
- Expected output and affected interests
- Authority, liability, and reliance relations
The matter determines what must be tested.
- Domain protocols and evidence requirements
- Scientific and causal burdens
- Economic demand and reciprocity
- Institutional rules, authority, and liability
Attempt to disconfirm, narrow, or block each proposition.
- Identity, consistency, and correspondence
- Possibility, causality, and scope
- Reciprocity and full accounting
- Authority, warrantability, and decidability
Return the strongest result the record can carry.
- Supported and failed content
- Typed diagnostics and skipped tests
- Strongest supportable repair
- Open conditions, provenance, and next operation
Fluent, compact, and institutionally underdetermined.
The sentence contains multiple propositions and proposed operations.
These are different defects and require different repairs.
The record can preserve this without granting unrelated secondary rights.
The repair narrows permission to what the demand and evidence can support.
Not permission to accept, sign, spend, transfer rights, or bind.
Semantic compilation is not stylistic rewriting. It changes an opaque sentence into inspectable propositions, failures, and conditions of reliance.
What the Compiler Is Asked For
A conventional compiler is asked to produce a machine that acts. This one is asked to produce a refusal.
Compilation failure is not a defect in the run. It is the deliverable — the explained error is the finding.
Because the logic is constructive and bottom-up, existence has to be built rather than asserted. “A square circle” cannot pass, because nothing can be constructed that satisfies both terms. “Justice means goodness” cannot pass either, because no actor, transfer, harm, obligation, or test has been supplied to build from. In neither case is the compiler failing to understand the claim. It has located the exact point at which the claim stopped referring to anything.
Discretion is the one input the compiler cannot supply. Where a claim would need someone’s judgment to proceed — a missing measurement, an ambiguous reference, an incomplete rule, an irreducible preference — the system reports that condition rather than guessing past it. This is the Runcible standard of decidability implemented as a type system instead of described as a policy: satisfaction of the demand for infallibility appropriate to the context, without the necessity of discretion.
The compile step therefore returns three outcomes rather than two — ternary logic, in the research vocabulary. Those three outcomes are the result states. What an institution reads from a result state is an action state.
Take the text as written
A description, an argument, a narrative, a contract term, or a generated answer — without first improving it.
Restate it so it can be checked
Actors, actions, objects, conditions, and measurements become explicit. What the sentence left implicit is supplied or marked missing.
Separate what is claimed
The prose is divided into individual claims, each of which can receive a different result.
Type the assertions
Objects, relations, operations, burdens, limits, and open conditions become typed parts of the matter rather than prose.
Run the test
Construct what the claim requires, then attempt to falsify it. Errors are emitted and explained rather than absorbed.
Return what the run establishes
A construction that survived, an explained failure, or a matter that cannot close without discretion.
A fluent generated claim has no compile step. That is the whole difference between a candidate and an adjudicated result, and it is the mechanism behind the shorter statement that models hypothesize and Runcible adjudicates.
Action states: Certified, Survives, Escalated
The construction held under the burdens that were run. What separates the three is authority: a legitimate role has certified the result and warranty attaches, or no authority decision has been taken and reliance stays inside the stated limits, or the result is supportable but the party holding it may not act on it and the exact version is routed to the role that may.
The test is identical in all three. What differs is who holds the decision.Action states: Repairable, Fails, Non-warrantable
Something specific could not be constructed, or did not survive falsification. What separates the three is what is left standing: a narrower version the record still supports, nothing at all, or a claim that may be supportable and that the institution still cannot attach proportional warranty and restitution to.
The error names what must change before reliance is possible.Action states: Undecidable, Blocked
Missing information, an ambiguous reference, insufficient measurement, an incomplete rule, an unresolved alternative, or an irreducible preference. What separates the two is whether the process ran at all: the matter is open and can be reopened by supplying what is named, or a required protocol, source, or permission was absent and no operation may proceed until it is restored.
The matter stays open and states what would close it.A result state is the outcome of the test. An action state is what the institution may do next. They are two jobs, not two names for one list: three result states, eight action states, and the fact that selects among the siblings above is always supplied by the institution rather than by the test. No action state adds a fourth outcome, and none is a governance vocabulary added on top of the compiler. The controlled definitions and the full mapping sit with the diligence material in the investor and partner glossary.
Decidability ends where discretion begins. A decision is an act of choice; decidability is the elimination of the need for choice.
Why Failure Must Be Specific
A confidence score cannot tell the institution what failed or how to repair it.
Two outputs can receive the same low score for entirely different reasons. One may need a definition. Another may be physically impossible. Another may be true but unauthorized.
Runcible treats failure as structured information. A diagnostic names the proposition, test, observed defect, consequence, provenance, repair condition, and whether the matter should be revised, supplied with evidence, escalated, blocked, or preserved as undecidable.
This is what makes the process useful to people and downstream systems. The result can drive a precise evidence request or workflow transition rather than another round of generic prompting.
The object is not stable.
“Service data” conflates content, telemetry, metadata, and derived information.
Repair: enumerate objects and rights separately.The verb hides incompatible actions.
“Use” may mean process, retain, analyze, train, profile, sell, or transfer.
Repair: name each operation and condition.The proposition outruns its record.
A claimed necessity is asserted without architecture, alternatives, or evidence.
Repair: supply evidence or narrow the claim.The exchange does not satisfy the stated demand.
A customer demands a service while the term supplies the vendor an additional durable asset.
Repair: remove, price, limit, or reciprocate the transfer.The result may be supportable but not permitted.
The analyst can propose a repair but cannot accept a contract or bind the organization.
Repair: route the exact version to the legitimate role.The record cannot responsibly close.
Required evidence, protocol, authority, or conditions are absent.
Repair: preserve open state and state what would permit rerun.A useful error is a map from what failed to what the institution must learn or change.
The Category Distinction
Rules engines decide known cases inside a predefined world. Runcible helps establish what world the language is claiming.
Constructed Basis, Bounded Claim
Probability may inform judgment. It cannot substitute for the structure that makes reliance defensible.
Runcible does not reject statistical evidence, uncertainty, or confidence estimates. It rejects using a scalar score as a proxy for identity, evidence, causality, authority, or liability.
The relevant artifact is constructive: what was asserted; how terms were defined; which evidence and methods were used; what tests ran or were skipped; what survived; what failed; what remains open; what would falsify the result; who may rely on it; and which authority must decide.
This is proof-like in the engineering sense of an inspectable construction. It is not a claim that Runcible produces infallible formal proofs of empirical, legal, medical, or institutional truth.
How uncertain is an estimate under a model?
Useful evidence, but dependent on definitions, data, method, scope, and assumptions.
Can the proposition be stated and tested against reality?
Identity, measurement, correspondence, possibility, causality, and falsification.
Does the supplied information or action satisfy the demand?
Interests, reciprocity, cost transfer, externalities, remedy, and full accounting.
May another party responsibly rely within declared limits?
Evidence sufficiency, provenance, role, authority, liability, review, and revocation.
Runcible research investigates whether claims from different paradigms can be reduced to common operational burdens of state, operation, transformation, measurement, comparison, consequence, and test.
The legacy page presented universality as already proved. The public technical claim should be narrower: this reduction is the methodological thesis and implementation direction. Its domain coverage, completeness, and limits require continuing evidence.
The record is stronger than confidence theater because it makes the basis, limits, and missing conditions inspectable.
Where the Compiler Analogy Ends
A proposition can survive its tests and still be outside the institution’s authority, purpose, or acceptable risk.
What can survive examination?
Supported content, failure, repair, open conditions, provenance, and reliance limits.
What will the institution authorize?
Approve an exact version, request evidence, revise, negotiate, defer, reject, revoke, or preserve open.
What changes in institutional state?
Version, permission, assignment, workflow, publication, contract, account, action, and responsibility.
What actually happened?
Performance, cost, benefit, harm, challenge, correction, revocation, precedent, and memory.
The record remains attached to the institutional object, authority path, controlled transition, accounting, and returned consequence.
The host must preserve matter identity, provenance, result state, authority requirements, reliance limits, execution control, audit, and outcome write-back.
What This Page Establishes
The architecture can be explained publicly without pretending every formal element is equally mature or disclosed.
- RDL as typed operational representation
- Runcible AI as compiler-like clarification and testing process
- Foundation models as candidate and retrieval contributors, not authorities
- Structured judgment with diagnostics, repair, provenance, and open conditions
- Legitimate authority separated from epistemic success
- Runcible OS or another controlled host as execution environment
- Exact RDL syntax and production serialization
- Current type coverage and domain completeness
- Protocol inventory, selection logic, and execution evidence
- Verified interfaces among OS, AI, records, authority, and write-back
- Performance, reliability, security, and longitudinal product evidence
- Certification, warranty, insurance, and liability claims
The Technical Principle
Compilation can establish what survives. Only authority can decide what proceeds.
RDL makes consequential language operationally testable. Runcible AI determines what survives examination. Legitimate authority decides what may proceed. Runcible OS makes the authorized change real and preserves what follows.
