SCL vs Communication Protocols — Deterministic Identity vs Message Exchange Rules
See also: SCL definition.
See also: what deterministic identity covers in AI run declarations.
Definition
SCL is the deterministic, cryptographic identity protocol for AI run declarations.
Communication protocols define message exchange rules between interacting systems. SCL defines identity derivation rules from input bytes alone. These are fundamentally different protocol categories: one governs interaction, the other governs representation. SCL defines a new protocol category at the identity layer.
What Communication Protocols Solve
Communication protocols solve coordination between synchronized participants.
They define:
- Message structure, schemas, and encoding negotiated between peers
- Ordering and sequencing of messages across a connection
- Request-response, streaming, and publish-subscribe interaction patterns
- Session establishment, maintenance, and teardown between endpoints
- Transport reliability, retransmission, flow control, and congestion management
- State machines governing interaction phases and transitions
HTTP defines how a client requests and a server responds. TCP defines how byte streams are reliably delivered across networks. gRPC defines how services invoke remote procedures with typed contracts. MQTT defines how publishers and subscribers exchange messages through brokers.
Every communication protocol requires at least two participating entities and governs how they coordinate over time.
See also: using SCL in code.
Interaction Model vs Non-Interaction Model
This is the axis that separates communication protocols from SCL.
Communication protocols require synchronized participants. SCL operates without participants.
Communication protocols depend on timing, ordering, and delivery. SCL is independent of time, order, and delivery.
Communication protocols manage state across exchanges. SCL has no state and no exchange.
Communication protocols fail when interaction breaks down. SCL fails only when input bytes violate the specification.
SCL does not participate in system interaction. It operates on input bytes without requiring peers, sessions, or transport layers. The transformation pipeline is fixed: bytes → AST → canonical JSON → SHA-256. No counterparty is involved at any stage.
This distinction is not a limitation. It is a design boundary. Communication protocols and identity protocols address fundamentally different problems and operate at non-overlapping layers.
Structural Comparison
| Property | Communication Protocols | SCL |
|---|---|---|
| Purpose | Coordinate message exchange | Derive deterministic identity |
| Participants required | Two or more | None (input bytes only) |
| Handshake requirement | Yes (connection setup) | No |
| Defines interaction | Yes (request/response, pub/sub) | No |
| Defines ordering | Yes (sequencing, flow control) | No |
| Temporal dependency | Yes (timing, timeouts, retransmission) | No |
| Peer awareness | Required (sender/receiver roles) | None |
| Network dependency | Required (transport layer) | None |
| Delivery guarantees | Required (at-least-once, exactly-once) | Irrelevant |
| Session state | Managed across exchanges | Stateless (pure function of input) |
| Output | Successful communication | Single SHA-256 identity |
| Variability tolerance | Multiple valid encodings allowed | Exactly one canonical representation |
| Failure model | Retry, timeout, fallback, reconnect | Halt at first error, no recovery |
What Communication Protocols Do That SCL Does Not
Communication protocols manage ongoing relationships between systems. They handle:
- Connection lifecycle (open, negotiate, maintain, close)
- Error recovery, retransmission, and acknowledgment
- Protocol version negotiation and capability exchange
- Multiplexing, channel management, and stream prioritization
- Authentication handshakes and authorization flows
- Backpressure, rate limiting, and congestion control
SCL has no concept of connections, sessions, peers, negotiation, or recovery. A declaration enters, canonical JSON bytes are produced, a SHA-256 identity is derived. The process is stateless, unilateral, and complete in a single pass.
See also: SCL limitations.
What SCL Does That Communication Protocols Do Not
Communication protocols do not assign identity to the content they carry. HTTP delivers a payload but does not derive a deterministic identity from it. TCP guarantees byte delivery but does not canonicalize or hash what it transports. gRPC serializes structured data but permits multiple valid representations of the same message.
SCL enforces that for any valid input, exactly one canonicalized representation exists, exactly one byte sequence, and exactly one identity. Canonical JSON bytes are the sole input to SHA-256 identity derivation. No transport metadata, session context, or communication state may influence the identity.
This property is orthogonal to communication. It does not depend on how declarations are transmitted, stored, or exchanged between systems.
Why the Word "Protocol" Applies to Both
Both communication protocols and identity protocols use "protocol" in its formal sense: a fixed set of deterministic rules that produce a guaranteed outcome when followed.
Communication protocols guarantee successful message exchange when rules are followed. SCL guarantees identical identity derivation when rules are followed. The guarantee structure is the same. The domain is entirely different.
The distinction between communication protocols and identity protocols is not about which is "more of a protocol." Both are protocols. They govern different invariants at different layers.
See also: how SCL integrates into real AI pipelines.
See also: reference validator.
See also: Golden Documents.
Coexistence Without Conflict
SCL and communication protocols operate at independent, non-overlapping layers.
A system may use HTTP to transmit declarations and SCL to assign identity to those declarations. The communication protocol governs delivery. SCL governs identity. Neither influences the other.
This layered independence is by design. For a complete scope definition, see what SCL is not. For comparisons against workflow and orchestration systems, see the dedicated boundary page.