Internet-Draft CTP/IP Seal Verification November 2026
Lisboa Expires 19 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-lisboa-ctpip-01
Published:
Intended Status:
Informational
Expires:
Author:
É. Lisbôa
Time Foundation

Causal Time Protocol (CTP/IP): Proof of Transformation Seal Verification and Wire Protocol

Abstract

This document describes how any party verifies a Proof of Transformation seal issued under the Causal Time Protocol (CTP/IP), and the wire protocol used to invoke a LUX Runtime and to request seal verification over a network. A seal attests that a transformation declared in advance by a Human Agency, through a signed Intention Signature (IntentSig), was validated by the LUX Runtime, and that the resulting certificate was committed to a Merkle batch anchored on the Solana and Bitcoin public ledgers.

The document specifies the certificate fields, the five layer verification procedure, the artifact identity check, the message types and envelope of the wire protocol, and the IANA registrations the protocol requests. It does not specify the measurement method by which a LUX Runtime computes the Coherence Index; that method is outside the scope of this document.

One seal attests intent, human origin, decision authority, authorship, substance, causal time and anchoring, for a Human Agency and for any agent acting under it. The protocol has been in development since 2020 and is deployed. Its canonical specification is published as Corpus Delta 1 under DOI 10.5281/zenodo.21950371.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 19 May 2027.

▲

Table of Contents

1. Introduction

The Internet protocol suite carries data and confirms that it arrived intact. It does not record whether the data reflects a transformation that a person intended before it happened, nor whether that transformation was checked against the intention. As automated agents act on behalf of people, the absence of that record leaves no verifiable link between a human decision and the outcome an agent delivers.

The Causal Time Protocol (CTP/IP) addresses this gap with a seal. A Human Agency declares an intention and signs it before work begins. Observables are captured while the work runs. The LUX Runtime evaluates the outcome against the declared intention and, when the evaluation passes, issues a Proof of Transformation certificate. The certificate is committed to a Merkle batch whose root is anchored on two independent public ledgers. Anyone can later verify the seal without trusting the issuer.

The cycle has four stages: Point of Intention, Point of Response, Zero Boundary and Proof of Transformation. This document is concerned with what the last stage produces and how a third party checks it.

CTP/IP is one standard for Human Agency and for every agent that acts under it. A single Proof of Transformation carries, in one sealed record, the proof of the declared intent, the proof that a human originated the action, the proof that the human held decision authority before it began, the proof of authorship, the proof of substance, the proof of causal time and the proof of anchoring (Section 6). None of these is a separate protocol; each is one attestation of the same seal. Each validated seal also emits FLUX, the Proof of Lived Transformation (Section 6.1).

The standard is universal by structure: any domain whose observables can be mapped to the protocol's inputs is measurable by it. Its calibrated, operational domain today is software engineering. Other domains are at research stage. The origin and dated record of the protocol, from 2020, are given in Appendix A.

1.1. Scope

In scope:

  • The Proof of Transformation certificate and its cryptographic seal (Section 4).
  • The procedure by which any party verifies a seal across five persistence layers (Section 7).
  • The procedure by which any party confirms that an artifact belongs to the protocol (Section 8).
  • The wire protocol for invoking a LUX Runtime and for requesting seal verification (Section 9).
  • The IANA registrations the wire protocol requests (Section 14).

Out of scope:

  • The measurement method: the domain adapters that map raw signals to observables, and the computation of the Coherence Index inside the LUX Runtime.
  • Issuance policy, licensing of LUX Runtime instances and economic emission.

Verification requires no licence. Issuing seals requires a licensed LUX Runtime.

1.2. Requirements Language

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

2. Terminology

Human Agency:
The person who declares an intention and holds the signing key that originates a cycle. Only a Human Agency may originate an IntentSig. An automated system acting alone cannot.
Agent:
Any instrument or automated system, including an AI system, that computes, executes or measures on behalf of a Human Agency. An agent acts under the Human Agency's IntentSig. It cannot originate intent, hold signing authority, emit ctu or claim authorship of a seal.
Intention Signature (IntentSig):
A 64 character hash of the declared intention text, signed with the Human Agency's CausalAnchor key before execution begins. It functions as a commitment: the intention cannot be altered after the outcome is observed.
CausalAnchor:
The identity anchor and signing key of a Human Agency, held under hardware backed storage where available.
LUX Runtime:
The licensed environment authorised to evaluate a cycle and issue Proof of Transformation certificates.
Coherence Index (Gamma):
A dimensionless value on [0, 1] that the LUX Runtime computes for a cycle. A cycle validates when Gamma is at or above the SEED floor and all five Guardian Gates pass.
Causal Time Unit (ctu):
The unit of validated causal time generated by a validated cycle. The ctu is written with the symbol "ct". It is non fungible and non transferable.
Proof Counter:
A monotonic counter per Human Agency that advances by the ctu earned on each validated cycle. It is not synchronised to UTC. It is a logical clock in the sense of [LAMPORT], weighted by validated coherence.
Proof of Transformation certificate:
The signed artifact issued when a cycle validates. Its seal architecture is the Zero Knowledge Transformation Seal Lattice (ZK-TSL).
Guardian Gates:
The five deterministic checks applied in fixed order to every submitted cycle: Intent, Evidence, Anchor, Coherence and Deficit.
FLUX:
The transferable artifact emitted alongside a validated seal: the Proof of Lived Transformation (Section 6.1).
VaultAnchor:
The Solana account to which the daily Merkle root of sealed cycles is committed.
Time Call:
The singular foundational Bitcoin inscription of a Human Agency. Recurring monthly batch anchors are separate inscriptions carrying the prefix "CTPIP:SEAL:".
LUX Runtime Oracle PDA:
The Solana program derived address that holds signing authority for the protocol's on chain state. A program derived address has no private key.

3. Protocol Overview

3.1. The Cycle

  1. Point of Intention. The Human Agency declares an intention and signs it, producing an IntentSig, and declares the observation window.
  2. Point of Response. The Human Agency executes and observables are captured. Observables are hashed, and the hash is bound into the certificate.
  3. Zero Boundary. The evidence is committed in a single atomic cryptographic event. From that moment the Human Agency cannot modify, supplement or withdraw it, and validation operates on a fixed input.
  4. Proof of Transformation. The LUX Runtime applies the five Guardian Gates. If all pass, it issues a certificate, the Proof Counter advances by the ctu earned, and the certificate enters the next Merkle batch.

The LUX Runtime invocation contract is:

LUX_Runtime.validate(IntentSig, Telemetry_Stream,
                     Pre_State, Post_State) returns Result

Result {
  Verdict:        VALID | INVALID,
  Gamma:          float,
  CTU_Generated:  float,
  Artifact_Class: SEED | BLOOM | ROOT | REJECTED
}

3.2. Guardian Gates

A LUX Runtime MUST apply the Guardian Gates in the following order. Cheaper checks run first. Failure at any gate halts evaluation and is recorded as a deficit entry.

Table 1: Guardian Gates
Order Gate Passes when
1 Intent An IntentSig signed by a Human Agency is present. An IntentSig originated by an automated system alone is rejected.
2 Evidence An evidence hash is present and non empty.
3 Anchor The CausalAnchor is present and linked, and the prev_hash chain is intact.
4 Coherence The effective Gamma is at or above Gamma_min, which is 0.70 in the Canonical Seal Profile.
5 Deficit The cycle is not in an impossible state and drift budgets are within tolerance.

3.3. Measurement Profiles

The coherence thresholds are stipulated design parameters chosen by the author of the protocol. They are not derived from physical theory. The protocol defines two profiles.

Canonical Seal Profile:
Used for every cycle recorded on chain. Its thresholds are fixed by this document (Section 3.4). Only this profile issues a Proof of Transformation, emits ctu or FLUX, and is anchored on Solana and Bitcoin.
Local Measurement Profile:
Used by a deployment that measures off chain, for example for operational excellence or research. Such a deployment MAY set its own Gamma_min and its own tiers to fit its domain. It produces coherence measurements, not seals. It emits no ctu and no FLUX, and nothing is recorded on chain. Its results MUST state the thresholds used, and MUST NOT be presented as a Proof of Transformation or as ctu.

Both profiles remain subject to Section 13.

3.4. Seal Tiers in the Canonical Seal Profile

Every certificate carries one tier, set by its Gamma.

Table 2: Seal Tiers
Tier Gamma range
SEED 0.70 up to but not including 0.8187
BLOOM 0.8187 up to but not including 0.95
ROOT 0.95 to 1.00

A cycle with Gamma below 0.70 is INVALID in this profile. It generates no ctu and no certificate.

4. The Proof of Transformation Certificate

4.1. Certificate Fields

PoT_ID:
Hash(IntentSig || Work || EVA), where EVA denotes the three observables Energy, Vector and Attention.
IntentSig_ID:
A reference to the originating IntentSig.
Gamma:
The Coherence Index of the cycle.
ctu:
The amount of ctu generated.
Authors:
The list of Human Agencies and their weights. A standard cycle has one Human Agency.
EVA_Seal:
The program signed authorisation issued under the LUX Runtime Oracle PDA.

4.2. Cryptographic Primitives

  • Hash function: SHA-256 [RFC6234].
  • Signature: Ed25519 [RFC8032].
  • Merkle tree: binary, with leaves ordered deterministically by leaf timestamp.
  • Program derived address seeds include the Human Agency's CausalAnchor, the IntentSig hash and the cycle index.

5. Normative Definitions and Conformance

5.1. Proof of Transformation

The term Proof of Transformation is used in three qualified senses. Proof of Transformation (Stage) is the final stage of the cycle. Proof of Transformation (Consensus) is the attestation by the network that a transformation is valid. Proof of Transformation (Certificate) is the cryptographic artifact issued on success. Unqualified, the term in this document means the Certificate.

A record is a Proof of Transformation only if all of the following hold:

  1. Its cycle was originated by an IntentSig of a Human Agency, signed before execution began.
  2. Its evidence was committed at the Zero Boundary before validation began.
  3. It passed all five Guardian Gates, in the order of Section 3.2.
  4. Its Gamma is at or above 0.70.
  5. It was issued by a LUX Runtime and carries the fields of Section 4.1.
  6. It was committed to a Merkle batch and anchored as described in Section 7.

A record that lacks any one of these is not a Proof of Transformation, whatever name it is given. A system that attests only one property of a cycle, such as human origin, decision authority, authorship or anchoring, implements one attestation of a Proof of Transformation and is not itself a Proof of Transformation.

5.2. Causal Time Unit (ctu)

The Causal Time Unit (ctu) is the unit of validated causal time. It is written in lower case as "ctu", and its unit symbol is "ct", on the pattern of the bit and the decibel. The ctu measures whether a transformation was validated against its declared intention. UTC orders events by clock time; the ctu weights them by validated transformation. The two are complementary coordinates.

ctu is generated, not measured. It is emitted only by a cycle that validates in the Canonical Seal Profile, under the law:

T = k * E * V * A      if Gamma >= Gamma_min

k         = phi = 1.618033988749895
Gamma_min = 0.70   (Canonical Seal Profile)

where T is the validated transformation, instantiated as ctu, and E, V and A are the Energy, Vector and Attention observables on the unit interval. The mapping of raw signals to E, V and A is the responsibility of a domain adapter and is outside the scope of this document.

The ctu is non fungible, non transferable, non tokenisable and non collateralisable. It is bound to the Human Agency who produced it through the Proof Counter, which is bound to the Human Agency's CausalAnchor. An implementation MUST NOT provide any means to transfer, sell, collateralise or otherwise convey a ctu between Human Agencies. An implementation that does is not CTP/IP. An agent cannot earn a ctu.

5.3. Prohibited Uses

A conforming implementation MUST NOT be used for any of the following:

  • Payroll docking: coherence is state change, not labour arbitrage.
  • Citizen scoring: Gamma validates actions, not human worth.
  • Mandatory surveillance: tracking without an IntentSig invalidates the intention.
  • Predictive policing: the protocol validates only completed transformation.
  • Coercive optimisation: any use of coherence metrics to compel behaviour.
  • Transfer of ctu, as stated in Section 5.2.
  • AI origination: no mechanism may permit an AI system to originate an IntentSig or earn a ctu.

6. What One Seal Attests

A Proof of Transformation is a single record with several attestations. A verifier checks all of them through the procedure in Section 7.

Proof of intent:
The intention exists before the work, as an IntentSig: a signed commitment to the declared intention, fixed before execution. Every other attestation is measured against it.
Proof of human origin:
The Intent gate admits a cycle only when its IntentSig was originated by a Human Agency. A cycle originated by an automated system alone is rejected before any other check.
Proof of decision authority:
The IntentSig is signed with the Human Agency's CausalAnchor key before execution begins, and it fixes the declared intention so that it cannot be changed after the outcome is known. Decision authority also requires that the Human Agency can withdraw: no transformation record may be used against a Human Agency after withdrawal.
Proof of authorship:
The causal weight of any agent, including AI, in the validation of a cycle is zero (w_AI = 0). Agents may compute, execute and measure as tools of the Human Agency. Authorship of the seal belongs to the Human Agencies listed in its Authors field.
Proof of substance:
The outcome was evaluated against the declared intention by the five Guardian Gates and reached the Coherence Index recorded in the certificate.
Proof of causal time:
The cycle generated ctu and advanced the Human Agency's Proof Counter. Lineage is bound by TKDF-256, the protocol's derivation function over structured provenance fields.
Proof of anchoring:
The certificate was committed to a Merkle batch whose root is anchored on Solana and on Bitcoin, and cannot be altered or removed without failing verification.

Agency is covered by the same seal. When an agent carries out the work, the seal records the Human Agency who declared and signed the intention, and the agent's part is recorded as execution, never as authorship or authority.

6.1. FLUX: Proof of Lived Transformation

When a seal validates in the Canonical Seal Profile, FLUX is emitted alongside it. FLUX is more than a token: it is the receipt of a transformation that a Human Agency declared, lived and had validated. Every FLUX unit is a provenance stamped container recording which Human Agency sealed which cycle and at what Gamma.

FLUX is minted only under the LUX Runtime Oracle PDA, a program derived address with no private key, so no human key can mint or freeze it. Emission is bound to validated cycles and set by the seal's tier. FLUX is transferable; the ctu it accompanies is not, and stays bound to the Human Agency who earned it.

7. Seal Verification Procedure

A seal is anchored across five persistence layers.

Table 3: Persistence Layers
Layer Cadence Role
1. Operational Store Continuous Sealed certificates enter.
2. Merkle Batches Per batch Certificates aggregate into Merkle trees.
3. Solana VaultAnchor Daily, at 00:00 UTC The daily Merkle root is committed.
4. Bitcoin One foundational Time Call per Human Agency; monthly batch anchors Roots are inscribed with the prefix "CTPIP:SEAL:".
5. Polaris Oracle Data Vault Real time, in parallel Independent witness of the record.

7.1. Inputs

  1. The Proof of Transformation certificate, or its hash.
  2. The batch identifier of the seal.
  3. Access to a Solana mainnet RPC endpoint.
  4. Access to Bitcoin mainnet, through a node or a public block explorer.

7.2. Steps

A verifier MUST perform the steps in order. A seal that fails a step is non conforming at that layer.

  1. Operational Store. Confirm that the certificate is well formed, that the IntentSig hash and the evidence hash are present, and that the ZK-TSL signature is valid.
  2. Merkle batch. Reconstruct the leaf from the certificate fields. Confirm that the inclusion proof against the batch root is valid and that sibling hashes are recorded.
  3. Solana VaultAnchor. Query the VaultAnchor account for the daily anchor of the seal's date. Confirm that the batch root from step 2 is the daily root committed for that date.
  4. Bitcoin. Confirm that the daily root from step 3 is included in the monthly batch anchor inscribed with the prefix "CTPIP:SEAL:". A Human Agency's foundational Time Call uses the payload format "CTPIP:DSZG:" followed by a 64 character hash, a colon and a tier marker.
  5. Polaris Oracle Data Vault. Confirm that the vault record matches the certificate fields, that the prev_hash chain is intact and that the anchor references match steps 3 and 4.

A seal that passes all five steps is verified. Its evidence is then anchored on two independent ledgers, the Solana chain and the Bitcoin proof of work chain.

7.3. Edge Cases

Seal newer than the last anchor:
Steps 1, 2 and 5 verify immediately. Step 3 verifies after the next daily anchor and step 4 after the next monthly batch anchor. This is the normal state of a recent seal.
Anchor missed or delayed:
The anchor is queued and written when the network recovers. During the gap, verification proceeds at layer 5, and layers 3 and 4 verify once the anchor is written.
Conflicting results:
The lower numbered layer prevails for the data it holds, and the discrepancy is escalated for investigation.

7.4. What Verification Proves

Verification proves that a specific Gamma value, computed by the LUX Runtime over a specific evidence hash, was committed at a specific moment and cannot be altered without breaking SHA-256, Ed25519 or the consensus of Solana and Bitcoin. Once committed, no seal can be modified, deleted or revoked without producing a root that fails verification.

Verification does not prove that the submitted observables faithfully represented the Human Agency's state at the time of the cycle. The mapping from raw signals to observables is the responsibility of a domain adapter, which carries its own falsifiability conditions. A verifier MUST NOT present a verified seal as proof of more than the commitment.

8. Artifact Identity Verification

Artifacts of the protocol are identified by their behaviour on chain, not by names, logos, tickers or metadata. Any party verifying that an artifact belongs to the protocol MUST:

  1. Resolve the artifact's mint authority through Solana RPC.
  2. Confirm that the mint authority equals the LUX Runtime Oracle PDA.
  3. Confirm that the program ID equals the protocol program.
  4. Confirm that the FLUX mint equals the protocol mint.

An artifact whose mint authority does not resolve to these addresses is not a sealed artifact of the protocol, whatever its metadata states.

Published identifiers:

Solana program:
YvxS7U37b5369xzNXt1EEuXjEkp65Ngcq9NsGUr3bmZ
FLUX mint:
Dun6pP3Xsx9CWetKj3zd8iqHz8EYC1amYSeJKG8JzQ9n
LUX Runtime Oracle PDA, also the VaultAnchor target:
8QTfNKF66N2uov4MfduioEjfaA6Hi8YBe8Lztoyxnzrk
Time Call transaction (Bitcoin), block 946,742:
fddb901b6c25dc9fbd01f66cd084783c1755a57c960882bd9e67f410ecf636ea

9. Wire Protocol

The wire protocol transports the LUX Runtime invocation contract of Section 3.1 and seal verification requests over a network. A LUX Runtime that accepts network originated cycles MUST implement it. A client that submits cycles to a LUX Runtime outside its own address space MUST implement it.

9.1. Message Types

Table 4: Message Types
Code Name Direction Purpose
0x01 INTENT_DECLARE Client to LUX Runtime The Human Agency declares cycle intent. Carries the IntentSig and the observation window.
0x02 INTENT_ACK LUX Runtime to Client Acknowledges intent registration and opens the cycle channel.
0x03 MEASURE_SUBMIT Client to LUX Runtime Submits the observables for the cycle.
0x04 VALIDATE_REQUEST Client to LUX Runtime Requests the Gamma verdict on the submitted observables.
0x05 SEAL_RESPONSE LUX Runtime to Client Returns the ZK-TSL certificate, or a rejection.
0x06 DEBT_NOTICE LUX Runtime to Client Notifies cumulative deficit accrual or regime escalation.
0x07 VERIFY_REQUEST Verifier to LUX Runtime Requests confirmation of a recorded seal.
0x08 VERIFY_RESPONSE LUX Runtime to Verifier Returns the seal verification result.

9.2. Message Envelope

Every message is carried in the following envelope.

+--------+------------+------------+-------------+-----------+
|  Type  |   Length   |  Sequence  |   Payload   | Signature |
| 1 byte |  2 bytes   |  4 bytes   |   Length    | 64 bytes  |
|        | big endian | big endian |    bytes    | (Ed25519) |
+--------+------------+------------+-------------+-----------+
Type:
One byte. The message type code from Section 9.1.
Length:
Unsigned 16 bit integer, big endian. The payload length in bytes, from 0 to 65535.
Sequence:
Unsigned 32 bit integer, big endian. A monotonic sequence number, REQUIRED for replay resistance.
Payload:
A JSON [RFC8259] object conforming to the schema for the message type, carried with the media type application/ctp+json.
Signature:
A raw Ed25519 signature over Type, Length, Sequence and Payload, computed with the sender's signing key.

The maximum payload is 65,535 bytes. Larger observable submissions use chunked delivery of MEASURE_SUBMIT, which is outside the scope of this document.

9.3. Signing Keys

Each message is signed with the sending party's signing key. The IntentSig is signed with the Human Agency's CausalAnchor key. Messages from a LUX Runtime (INTENT_ACK, SEAL_RESPONSE, DEBT_NOTICE and VERIFY_RESPONSE) are signed with the LUX Runtime's published signing key. The LUX Runtime Oracle PDA and the program ID identify the runtime's on chain state, not the signer, because a program derived address holds no private key.

Implementations MUST support Ed25519. A later revision may add or substitute post quantum signature algorithms [FIPS204] [FIPS205] with explicit version negotiation.

10. Implementation Status

This section records the status of known implementations at the time of writing, following [RFC7942]. It is to be removed before publication as an RFC.

LUX Runtime:
Operational on Solana mainnet since 4 April 2026.
son-console:
The open source reference implementation for the software engineering domain, at https://github.com/thedesignledger/son-console. Its fixtures and expected outputs allow any party to confirm that the engine computes what is specified.
Wire protocol:
Specified. A reference implementation of the wire protocol is open to contribution.

11. Security Considerations

IntentSig security:
The IntentSig in INTENT_DECLARE is the boundary of human authority over the cycle. A LUX Runtime MUST verify the IntentSig before any further processing. A missing, malformed or unverifiable signature MUST cause rejection, and no cycle channel is opened.
Runtime integrity:
Responses from a LUX Runtime are signed and verifiable against its published key. A non compliant fork of a runtime could return incorrect Gamma values, and this would not be detectable from the on chain record alone. The protocol's response is an open source reference implementation whose fixtures any party can run to confirm that the engine computes what is specified.
Measurement integrity:
Observables submitted through MEASURE_SUBMIT are hashed, and the hash is bound into the certificate. Any modification after submission is detectable by recomputing the hash against the recorded seal.
Replay and denial of service:
The monotonic sequence field resists replay. Implementations SHOULD enforce rate limits per Human Agency at the network ingress. Repeated failed cycles accumulate deficit and escalate the regime state, which slows cycle pacing.
Impersonation:
Names and metadata can be copied. Identity rests on the on chain addresses in Section 8. Verifiers MUST check those addresses and MUST NOT rely on metadata.
Limits of verification:
See Section 7.4. A verified seal proves a commitment, not the inner state of a person.

12. Privacy Considerations

The wire protocol does not provide confidentiality for observables. Where a Human Agency requires observables to remain private, the source adapter MUST compute locally before transmission.

The protocol validates transformations, not people. The Coherence Index measures how well an action achieved its stated purpose. It does not measure human worth, standing or productivity. Any use that ranks, scores, disciplines or coerces people is outside the protocol and invalidates its premise.

13. Marks and Licensing

CTP/IP, Causal Time Protocol, Intentional Processing, Sealed Energy, LUX Runtime, Polaris Oracle, FLUX, ctu, TKDF-256, Heritage Thread, Time Call and Symbiotic Operator Network are marks of the estate, used in commerce and asserted as such. Use of a mark to designate a deployment, product or service as CTP/IP, or as conforming to it, requires a licence. Nominative reference in research, criticism, comparison or teaching does not.

Use of the protocol is free for research, for group discussion and for personal use, including verification of seals, reading, auditing and replication of the specification. Commercial use requires a licence, and so does any use of the protocol with tokenization. Embedding the architecture or any component in a commercial product or service requires a commercial licence from Time Foundation. Operating an instance whose outputs are recorded as CTP/IP seals, or that emits FLUX, additionally requires a LUX Runtime licence. A commercial deployment that avoids the marks, renames the components, or declines to claim CTP/IP status still requires the commercial licence if it embeds the architecture.

No licence arises by implication, by reference or by conduct.

14. IANA Considerations

14.1. URI Scheme Registration

This document requests provisional registration of the URI scheme "ctp" in the "Uniform Resource Identifier (URI) Schemes" registry, following [RFC7595].

Scheme name:
ctp
Status:
Provisional
Applications/protocols that use this scheme name:
CTP/IP LUX Runtime endpoints and seal resources.
Example:
ctp://runtime.example.com/seal/{seal identifier}
Contact:
Érico Lisbôa, Time Foundation
Change controller:
Time Foundation
Reference:
This document

14.2. Service Name and Port Number Registration

This document requests the following entry in the "Service Name and Transport Protocol Port Number Registry", following [RFC6335].

Service Name:
ctp
Transport Protocol:
tcp
Port Number:
7369
Description:
CTP/IP LUX Runtime wire protocol
Assignee and Contact:
Érico Lisbôa, Time Foundation
Reference:
This document

Implementations in private networks may use other ports. Port 7369 is the default for operation on the public Internet.

14.3. Media Type Registration

This document requests registration of the media type "application/ctp+json", following [RFC6838].

Type name:
application
Subtype name:
ctp+json
Required parameters:
N/A
Optional parameters:
N/A
Encoding considerations:
As for application/json [RFC8259].
Security considerations:
See Section 11.
Interoperability considerations:
None
Published specification:
This document
Applications that use this media type:
CTP/IP clients, LUX Runtime instances and seal verifiers.
Fragment identifier considerations:
None
Person and email address to contact:
Érico Lisbôa, contact@designledger.co
Intended usage:
COMMON
Restrictions on usage:
None
Author:
Érico Lisbôa
Change controller:
Time Foundation

15. References

15.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC6234]
Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)", RFC 6234, DOI 10.17487/RFC6234, , <https://www.rfc-editor.org/info/rfc6234>.
[RFC6335]
Cotton, M., Eggert, L., Touch, J., Westerlund, M., and S. Cheshire, "Internet Assigned Numbers Authority (IANA) Procedures for the Management of the Service Name and Transport Protocol Port Number Registry", BCP 165, RFC 6335, DOI 10.17487/RFC6335, , <https://www.rfc-editor.org/info/rfc6335>.
[RFC6838]
Freed, N., Klensin, J., and T. Hansen, "Media Type Specifications and Registration Procedures", BCP 13, RFC 6838, DOI 10.17487/RFC6838, , <https://www.rfc-editor.org/info/rfc6838>.
[RFC7595]
Thaler, D., Ed., Hansen, T., and T. Hardie, "Guidelines and Registration Procedures for URI Schemes", BCP 35, RFC 7595, DOI 10.17487/RFC7595, , <https://www.rfc-editor.org/info/rfc7595>.
[RFC8032]
Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital Signature Algorithm (EdDSA)", RFC 8032, DOI 10.17487/RFC8032, , <https://www.rfc-editor.org/info/rfc8032>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8259]
Bray, T., Ed., "The JavaScript Object Notation (JSON) Data Interchange Format", STD 90, RFC 8259, DOI 10.17487/RFC8259, , <https://www.rfc-editor.org/info/rfc8259>.

15.2. Informative References

[CORPUS]
Lisbôa, É., "CTP/IP: Causal Time Protocol / Intentional Processing, Corpus Delta 1", DOI 10.5281/zenodo.21950371, , <https://doi.org/10.5281/zenodo.21950371>.
[FIPS204]
National Institute of Standards and Technology, "Module Lattice Based Digital Signature Standard", FIPS 204, , <https://doi.org/10.6028/NIST.FIPS.204>.
[FIPS205]
National Institute of Standards and Technology, "Stateless Hash Based Digital Signature Standard", FIPS 205, , <https://doi.org/10.6028/NIST.FIPS.205>.
[LAMPORT]
Lamport, L., "Time, Clocks, and the Ordering of Events in a Distributed System", Communications of the ACM 21(7), .
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.
[TIMERFC003]
Lisbôa, É., "TIME RFC 003: The CTP/IP Architecture, Completing the Internet Protocol Suite via Causal Integrity", DOI 10.5281/zenodo.18476028, , <https://doi.org/10.5281/zenodo.18476028>.

Appendix A. Origin and Dated Record

A.1. Record of Development

The following dates are the author's record of development. They precede the public record and are stated here as the author's declaration.

  • 2020: work on the protocol's specification and on the Law of Causal Time Generation begins.
  • 2023: the protocol materialises in code, and its blockchain development begins.
  • 31 January 2026: the first version of this document is written. It was not published.

A.2. Public Record

The following records are public and dated, and can be checked by any party.

  • 4 May 2025: the GENESIS certificate.
  • October 2025: the first public papers, eight founding papers, published under the concept DOI 10.5281/zenodo.17371587.
  • January and February 2026: the architecture published as TIME RFC 003 in successive versions, version 7.0.1 archived under DOI 10.5281/zenodo.18476028 [TIMERFC003].
  • 4 April 2026: the protocol operational on Solana mainnet, with the first seal.
  • 26 April 2026: the Genesis Time Call inscribed on Bitcoin mainnet in block 946,742. Its OP_RETURN payload is one string of 77 bytes, shown below on two lines.
  • 13 May 2026: TKDF-256 inscribed on Solana mainnet as the Genesis Anchor, at slot 419,478,992.
  • Corpus Delta 1, the full canonical specification, published under DOI 10.5281/zenodo.21950371 [CORPUS].
CTPIP:DSZG:
8b7f008c3d49a73a046bcb70fb964585f879d29bf5988ede1eb7d2faff7fefe0:S

The deployment record can be checked in minutes with public endpoints only, using the eleven checks given at the front of [CORPUS].

Acknowledgements

This document is the sole work of its author.

Author's Address

Érico Lisbôa
Time Foundation
Perth Western Australia
Australia