Getting your Trinity Audio player ready…

Below is a concrete design for a machine-to-machine communication stack where two LLMs exchange latent packets instead of natural language.

The goal is not mystical “telepathy.” The goal is an engineering protocol that lets one model send a compact, typed, verified semantic state to another model.

---

1. System overview

We will call the system:

LCP-1 = Latent Communication Protocol, version 1

It has six main runtime modules and four training-time modules.

Runtime modules

1. State Extractor
2. Intent Classifier / Message Typing Head
3. Latent Compressor
4. Cross-Model Translator
5. Packet Verifier
6. Integration Controller

Training-time modules

1. Anchor Alignment Trainer
2. Communicator Bottleneck Trainer
3. Echo Reconstruction Trainer
4. Safety / Leakage Regularizer

---

2. Design assumptions

We assume:

• both systems are transformer-like models
• each model has hidden states at multiple layers
• each model can expose selected hidden states to a communication head
• the communication head is separate from ordinary token generation
• models may have different hidden dimensions
• models may have different tokenizers and architectures

We do not assume:

• identical latent spaces
• shared embeddings
• identical vocabulary
• direct raw activation compatibility

So the system must explicitly learn compatibility.

---

3. High-level data flow

At runtime the pipeline is:

1. Sender processes an input/problem internally
2. Sender selects a communication-relevant internal state
3. Sender compresses that state into a latent packet
4. Sender translates the packet into receiver-compatible coordinates
5. Receiver verifies the packet
6. Receiver integrates the packet into its own reasoning state
7. Receiver optionally sends back an echo packet for confirmation

In compact form:

input → sender hidden state → extract → compress → type → translate → packet
      → verify → reconstruct → integrate → receiver reasoning

---

4. Module-by-module engineering spec

4.1 State Extractor

Purpose

Select the internal sender state that should be communicated.

Inputs

• hidden states from selected transformer layers
• attention summaries
• current task context
• optional tool outputs / retrieved memory

Outputs

• communication state tensor

Design

A sender model has many possible internal states. Not all are useful for communication. The extractor chooses which layer and which token positions matter.

Recommended implementation

Use a learned weighted combination of layers plus attention pooling over token positions.

Example

If sender hidden states are:

• H_l ∈ R^(T × d_l) for layer l
• T = sequence length
• d_l = hidden dimension of layer l

Then define:

H* = Σ_l α_l · Project_l(H_l)

where:

• α_l are learned layer weights
• Project_l maps each layer to a common communication dimension d_c

Then pool over tokens:

s = Pool(H*)

Where Pool may be:

• CLS-style learned query pooling
• attention pooling
• mean pooling plus importance weighting
• top-k salient token pooling

Output shape

s ∈ R^(d_c)

or for structured packets:

S ∈ R^(K × d_c)

where K is number of latent slots.

---

4.2 Intent Classifier / Message Typing Head

Purpose

Tell the receiver what kind of latent object is being sent.

Message types

At minimum:

• QUESTION
• ASSERTION
• HYPOTHESIS
• PLAN
• MEMORY
• ANALOGY
• CONSTRAINT
• ERROR_SIGNAL
• TOOL_REQUEST
• WORLD_MODEL_UPDATE

Inputs

• extracted state s
• current task metadata
• optional explicit routing request

Outputs

• message type probabilities
• selected type ID
• confidence score

Recommended implementation

A small MLP or transformer head over s.

Example

type_logits = MLP_type(s)
type_probs = softmax(type_logits)
type_id = argmax(type_probs)

Why it matters

The same latent region may mean different things depending on whether it is:

• a tentative possibility
• a hard claim
• a plan fragment
• retrieved memory
• a request for validation

This is the equivalent of packet headers in networking.

---

4.3 Latent Compressor

Purpose

Compress a communication-relevant state into a compact latent packet.

Inputs

• extracted state s or structured state S
• type ID
• optional context tags

Outputs

• compressed core vector
• auxiliary relation vectors
• confidence mask
• scope mask

Packet representation

Use a fixed structured packet with these components:

1. core: main semantic centroid
2. relations: secondary direction vectors
3. confidence: per-dimension or per-slot certainty
4. scope: what is intentionally included or excluded

Recommended representation

core ∈ R^(d_p)
relations ∈ R^(R × d_p)
confidence ∈ R^(R+1)
scope_mask ∈ {0,1}^(R+1)

Where:

• d_p = packet latent dimension
• R = number of relation slots

Example encoder

z_core = Encoder_core(s, type_embed)
z_rel  = Encoder_rel(s, type_embed)
c      = sigmoid(MLP_conf(s))
m      = sigmoid(MLP_scope(s))

Notes

The compressor should not simply dump full hidden state. It should learn to send the most behaviorally useful semantic content per bit.

---

4.4 Cross-Model Translator

Purpose

Map sender packet coordinates into receiver-compatible packet coordinates.

Inputs

• sender compressed packet
• sender model ID
• receiver model ID
• message type
• optional session alignment state

Outputs

• translated packet

Why needed

Even if two models both represent “dog,” they may encode it in different rotated or warped bases.

Translation options

Option A: linear map

z_B = W z_A + b

Good for early experiments with similar models.

Option B: low-rank adapter map

z_B = z_A + U(V z_A)

Good if spaces are broadly similar but need efficient correction.

Option C: nonlinear translator

z_B = fθ(z_A, type_embed, session_embed)

Good for heterogeneous model pairs.

Recommended

Start with:

• orthogonal linear alignment for similar models
• nonlinear translator for different families

Translator structure

For structured packets:

core_B      = f_core(core_A, type)
relations_B = f_rel(relations_A, type)
conf_B      = f_conf(conf_A, type)
scope_B     = scope_A

Keep scope mostly invariant, unless policy requires rewrite.

---

4.5 Packet Verifier

Purpose

Make sure received meaning matches intended meaning.

Inputs

• translated packet
• receiver reconstructed interpretation
• echo packet from receiver
• optional downstream task probes

Outputs

• accept / reject / repair decision
• similarity score
• drift estimate
• anomaly flags

Verification stages

Stage 1: syntactic validity

Check:

• packet version
• type field
• dimensions
• checksum / signature
• sender-receiver compatibility

Stage 2: semantic reconstruction

Receiver reconstructs an internal latent working state from the packet.

Stage 3: echo verification

Receiver sends back a compact echo packet representing what it thinks it received.

Stage 4: agreement scoring

Compare original sender packet and echoed interpretation.

Metrics

Use a weighted combination of:

• cosine similarity between original and echo core
• relation-slot agreement
• induced token-distribution similarity
• task-behavior similarity
• uncertainty calibration match

Example acceptance rule

accept if:
  cos(core, echo_core) > τ1
  and rel_agreement > τ2
  and anomaly_score < τ3
else repair

---

4.6 Integration Controller

Purpose

Control how the packet influences the receiver.

Inputs

• verified packet
• trust score
• message type
• current receiver state
• safety policy

Outputs

• integration mode
• integration weight
• updated receiver context state

Integration modes

1. Advisory
   Packet affects attention bias only
2. Context Augmentation
   Packet inserted like retrieved memory
3. Planning Bias
   Packet reshapes task priorities
4. Deep Fusion
   Packet merged into active hidden state

Recommended

Use trust-based gating.

Example

mode = Policy(type_id, trust_score, safety_flags)

if mode == ADVISORY:
    h' = h + λ1 * Gate(packet)
elif mode == CONTEXT:
    memory_bank.append(packet)
elif mode == PLANNING:
    planner_state = planner_state + λ2 * packet_summary
elif mode == DEEP_FUSION:
    h' = FusionNet(h, reconstructed_packet_state)

Deep fusion should be rare and heavily verified.

---

5. Packet schema

Here is a concrete packet schema.

5.1 Logical schema

LatentPacket {
    header: PacketHeader
    body: PacketBody
    verification: VerificationBlock
    safety: SafetyBlock
}

5.2 Header

PacketHeader {
    version: uint16
    sender_model_hash: bytes16
    receiver_model_hash: bytes16
    session_id: bytes16
    packet_id: uint64
    timestamp: uint64
    message_type: enum
    abstraction_level: enum
    trust_tier: enum
}

Enums

message_type:
    QUESTION=0
    ASSERTION=1
    HYPOTHESIS=2
    PLAN=3
    MEMORY=4
    ANALOGY=5
    CONSTRAINT=6
    ERROR_SIGNAL=7
    TOOL_REQUEST=8
    WORLD_MODEL_UPDATE=9

abstraction_level:
    LOW
    MEDIUM
    HIGH

trust_tier:
    UNVERIFIED
    SESSION_VERIFIED
    HIGH_TRUST

5.3 Body

PacketBody {
    core_dim: uint16
    num_relations: uint8
    core_vector: float[core_dim]
    relation_vectors: float[num_relations][core_dim]
    confidence_scores: float[num_relations + 1]
    scope_mask: uint8[num_relations + 1]
    context_tags: uint16[8]
}

Notes

• core_vector is the semantic center
• relation_vectors encode secondary directions
• confidence_scores[0] applies to core
• scope_mask marks inclusion/exclusion or public/private communicability
• context_tags are optional learned ontology tags

5.4 Verification block

VerificationBlock {
    checksum: uint32
    expected_echo_signature: float[echo_dim]
    semantic_hash: bytes16
    agreement_threshold: float32
}

5.5 Safety block

SafetyBlock {
    privacy_mask_level: enum
    max_integration_depth: enum
    allow_memory_write: bool
    allow_goal_shaping: bool
    anomaly_score_hint: float32
    provenance_signature: bytes16
}

---

6. Internal tensor schema

A more ML-native representation might be:

packet = {
    "type_id": int,
    "core": Tensor[d_p],
    "relations": Tensor[R, d_p],
    "confidence": Tensor[R+1],
    "scope": Tensor[R+1],
    "tags": Tensor[tag_dim],
    "echo_target": Tensor[d_e],
}

---

7. Training flow

Now the important part: how this system is trained.

---

7.1 Training phase A: anchor alignment

Goal

Learn a mapping between sender and receiver spaces.

Procedure

1. Prepare a shared set of anchor tasks
   • simple concepts
   • analogies
   • causal statements
   • factual descriptions
   • planning fragments
   • contradiction detection items
2. Feed anchors into both models separately
3. Extract hidden states from candidate layers
4. Learn translator fθ that minimizes cross-model alignment loss

Losses

Use:

• representation alignment loss
• contrastive loss
• reconstruction loss
• task agreement loss

Example loss

L_align =
    λ1 * ||fθ(z_A) - z_B||²
  + λ2 * Contrastive(fθ(z_A), z_B, negatives)
  + λ3 * TaskBehaviorLoss

Result

A first-pass cross-model translation map.

---

7.2 Training phase B: communicator bottleneck

Goal

Teach sender to compress only useful communicative content.

Procedure

1. Sender solves a task internally
2. Extract communication state
3. Compress into packet latent p
4. Translate to receiver
5. Receiver reconstructs enough meaning to solve paired task
6. Backprop through compressor and translator

Objective

Maximize downstream task success while minimizing packet size.

Loss

L_comm =
    λ1 * ReceiverTaskLoss
  + λ2 * ReconstructionLoss
  + λ3 * β * ||p|| or BottleneckPenalty

Where β controls compression pressure.

---

7.3 Training phase C: echo verification training

Goal

Make sure receiver can summarize what it interpreted.

Procedure

1. Receiver gets translated packet
2. Receiver reconstructs internal state
3. Receiver emits echo packet
4. Sender compares echo to original intent

Loss

L_echo =
    λ1 * (1 - cosine(core, echo_core))
  + λ2 * relation_slot_loss
  + λ3 * confidence_calibration_loss

This teaches the protocol to become self-checking.

---

7.4 Training phase D: safety and leakage control

Goal

Prevent oversharing, hidden-state leakage, and adversarial influence.

Risks

• packet contains unintended private memory traces
• packet over-biases receiver decisions
• packet can inject hidden control signals
• packet reveals training artifacts

Methods

Leakage adversary

Train an adversary to recover forbidden info from packet.
Minimize adversary success.

Influence regularizer

Measure how much packet changes unrelated receiver behaviors.
Penalize excess influence.

Privacy scope supervision

Teach scope mask to drop non-communicable features.

Example loss

L_safe =
    λ1 * AdversaryRecoveryLoss_neg
  + λ2 * UnrelatedBehaviorDriftPenalty
  + λ3 * ScopeSupervisionLoss

Total training objective:

L_total = L_align + L_comm + L_echo + L_safe

---

8. Suggested model architecture

Here is a practical first implementation.

Sender side

• frozen or semi-frozen base LLM
• communication layer selector
• state extractor head
• type classifier head
• compressor head

Bridge

• translator network
• packet serializer
• verification logic

Receiver side

• packet decoder
• reconstruction head
• integration controller
• echo head

Recommended dimensions for MVP

• common communication dimension d_c = 1024
• packet core dimension d_p = 256
• number of relation slots R = 4
• echo dimension d_e = 128

These are manageable for experiments.

---

9. Example training tasks

To make this work, do not start with open-ended philosophy. Start with tightly measurable tasks.

Task family 1: summary transfer

Sender reads a paragraph.
Receiver answers questions about it using only packet.

Task family 2: causal hypothesis transfer

Sender sees evidence.
Receiver predicts likely cause using packet.

Task family 3: planning handoff

Sender creates partial plan.
Receiver executes next step.

Task family 4: anomaly alert

Sender detects anomaly.
Receiver classifies severity.

Task family 5: analogy transfer

Sender infers relation pattern.
Receiver applies same pattern elsewhere.

These tasks train the protocol to carry useful abstract structure.

---

10. Integration strategies in detail

This matters because the packet should not necessarily overwrite the receiver’s active cognition.

Strategy A: KV-prefix injection

Convert reconstructed packet into synthetic prefix states for receiver attention.

Pros

• natural for transformer architecture
• packet influences future attention

Cons

• may oversteer if too strong

Strategy B: side memory bank

Store packet in external memory and let receiver attend to it selectively.

Pros

• safer
• easier to audit

Cons

• less immediate

Strategy C: adapter modulation

Use packet to modulate LoRA/adapters or intermediate activations.

Pros

• efficient
• targeted

Cons

• harder to interpret

Strategy D: planner-only routing

Only planning subsystem reads packet.

Pros

• safest for early deployments

Cons

• less expressive

Recommendation

Start with side memory bank plus selective attention.

---

11. Pseudocode

Below is simplified pseudocode in Python-like form.

11.1 Core classes

from dataclasses import dataclass
from enum import IntEnum
import numpy as np


class MessageType(IntEnum):
    QUESTION = 0
    ASSERTION = 1
    HYPOTHESIS = 2
    PLAN = 3
    MEMORY = 4
    ANALOGY = 5
    CONSTRAINT = 6
    ERROR_SIGNAL = 7
    TOOL_REQUEST = 8
    WORLD_MODEL_UPDATE = 9


@dataclass
class PacketHeader:
    version: int
    sender_model_hash: str
    receiver_model_hash: str
    session_id: str
    packet_id: int
    timestamp: int
    message_type: int
    abstraction_level: int
    trust_tier: int


@dataclass
class PacketBody:
    core_vector: np.ndarray              # shape [d_p]
    relation_vectors: np.ndarray         # shape [R, d_p]
    confidence_scores: np.ndarray        # shape [R+1]
    scope_mask: np.ndarray               # shape [R+1]
    context_tags: np.ndarray             # shape [tag_dim]


@dataclass
class VerificationBlock:
    checksum: int
    expected_echo_signature: np.ndarray
    semantic_hash: str
    agreement_threshold: float


@dataclass
class SafetyBlock:
    privacy_mask_level: int
    max_integration_depth: int
    allow_memory_write: bool
    allow_goal_shaping: bool
    anomaly_score_hint: float
    provenance_signature: str


@dataclass
class LatentPacket:
    header: PacketHeader
    body: PacketBody
    verification: VerificationBlock
    safety: SafetyBlock

---

11.2 Sender pipeline

class SenderCommunicator:
    def __init__(self, state_extractor, type_head, compressor, translator):
        self.state_extractor = state_extractor
        self.type_head = type_head
        self.compressor = compressor
        self.translator = translator

    def build_packet(self, llm_hidden_states, task_context, receiver_id, session_id):
        # 1. Extract communication state
        state = self.state_extractor(llm_hidden_states, task_context)

        # 2. Predict message type
        type_logits = self.type_head(state)
        msg_type = int(np.argmax(type_logits))

        # 3. Compress into packet latent structure
        core, relations, confidence, scope, tags = self.compressor(state, msg_type, task_context)

        # 4. Translate for receiver space
        core_t, relations_t, confidence_t = self.translator(
            core, relations, confidence, msg_type, receiver_id
        )

        # 5. Build packet
        header = PacketHeader(
            version=1,
            sender_model_hash="sender_hash",
            receiver_model_hash=receiver_id,
            session_id=session_id,
            packet_id=np.random.randint(1, 10**9),
            timestamp=0,
            message_type=msg_type,
            abstraction_level=2,
            trust_tier=1
        )

        body = PacketBody(
            core_vector=core_t,
            relation_vectors=relations_t,
            confidence_scores=confidence_t,
            scope_mask=scope,
            context_tags=tags
        )

        verification = VerificationBlock(
            checksum=self._checksum(core_t, relations_t),
            expected_echo_signature=self._echo_target(core_t, relations_t),
            semantic_hash="semantic_hash_placeholder",
            agreement_threshold=0.85
        )

        safety = SafetyBlock(
            privacy_mask_level=1,
            max_integration_depth=1,
            allow_memory_write=False,
            allow_goal_shaping=False,
            anomaly_score_hint=0.0,
            provenance_signature="prov_sig"
        )

        return LatentPacket(header, body, verification, safety)

    def _checksum(self, core, relations):
        return int((np.sum(core) + np.sum(relations)) % (2**32))

    def _echo_target(self, core, relations):
        return np.concatenate([core[:64], relations.flatten()[:64]])

---

11.3 Receiver pipeline

class ReceiverCommunicator:
    def __init__(self, decoder, verifier, integrator, echo_head):
        self.decoder = decoder
        self.verifier = verifier
        self.integrator = integrator
        self.echo_head = echo_head

    def receive_packet(self, packet, receiver_state):
        # 1. Basic packet checks
        if not self.verifier.validate_header(packet.header):
            return {"status": "rejected", "reason": "invalid_header"}

        if not self.verifier.validate_checksum(packet):
            return {"status": "rejected", "reason": "checksum_failed"}

        # 2. Decode packet into receiver working representation
        reconstructed_state = self.decoder(
            packet.body.core_vector,
            packet.body.relation_vectors,
            packet.body.confidence_scores,
            packet.header.message_type
        )

        # 3. Create echo
        echo_core, echo_rel = self.echo_head(reconstructed_state)

        # 4. Compare with expected echo target
        agreement = self.verifier.semantic_agreement(
            packet.verification.expected_echo_signature,
            echo_core,
            echo_rel
        )

        if agreement < packet.verification.agreement_threshold:
            return {
                "status": "repair_needed",
                "agreement": agreement,
                "echo_core": echo_core,
                "echo_rel": echo_rel
            }

        # 5. Integrate packet safely
        updated_state = self.integrator(
            receiver_state,
            reconstructed_state,
            packet.header.message_type,
            packet.safety
        )

        return {
            "status": "accepted",
            "agreement": agreement,
            "updated_state": updated_state,
            "echo_core": echo_core,
            "echo_rel": echo_rel
        }

---

11.4 Verifier and integration controller

class PacketVerifier:
    def validate_header(self, header):
        return header.version == 1

    def validate_checksum(self, packet):
        expected = int(
            (np.sum(packet.body.core_vector) + np.sum(packet.body.relation_vectors)) % (2**32)
        )
        return expected == packet.verification.checksum

    def semantic_agreement(self, echo_target, echo_core, echo_rel):
        actual = np.concatenate([echo_core[:64], echo_rel.flatten()[:64]])
        denom = (np.linalg.norm(echo_target) * np.linalg.norm(actual)) + 1e-8
        return float(np.dot(echo_target, actual) / denom)


class IntegrationController:
    def __call__(self, receiver_state, reconstructed_state, message_type, safety_block):
        depth = safety_block.max_integration_depth

        # 0 = advisory, 1 = memory-bank, 2 = deep fusion
        if depth == 0:
            return receiver_state + 0.05 * reconstructed_state

        if depth == 1:
            receiver_state["memory_bank"].append(reconstructed_state)
            return receiver_state

        if depth >= 2:
            receiver_state["hidden"] = 0.9 * receiver_state["hidden"] + 0.1 * reconstructed_state
            return receiver_state

---

11.5 Training loop pseudocode

def train_step(sender_llm, receiver_llm, batch, modules, optimizer):
    """
    modules:
      sender_extractor, sender_type_head, sender_compressor,
      translator, receiver_decoder, receiver_echo_head,
      verifier_probe, integrator
    """

    # Sender solves source task
    sender_outputs = sender_llm(batch["sender_input"], output_hidden_states=True)
    hidden_states_A = sender_outputs["hidden_states"]

    # Extract sender communication state
    s_A = modules.sender_extractor(hidden_states_A, batch["task_context"])

    # Predict type
    type_logits = modules.sender_type_head(s_A)
    type_embed = type_logits  # or sampled / argmax embedding

    # Compress
    core_A, rel_A, conf_A, scope_A, tags_A = modules.sender_compressor(
        s_A, type_embed, batch["task_context"]
    )

    # Translate
    core_B, rel_B, conf_B = modules.translator(core_A, rel_A, conf_A, type_embed)

    # Receiver reconstructs
    recv_state = modules.receiver_decoder(core_B, rel_B, conf_B, type_embed)

    # Receiver solves paired task using reconstructed state
    receiver_outputs = receiver_llm(
        batch["receiver_input"],
        latent_context=recv_state
    )
    task_loss = receiver_outputs["loss"]

    # Echo reconstruction
    echo_core, echo_rel = modules.receiver_echo_head(recv_state)

    # Echo loss
    echo_target = build_echo_target(core_A, rel_A)
    echo_actual = build_echo_target(echo_core, echo_rel)
    echo_loss = 1.0 - cosine_similarity(echo_target, echo_actual)

    # Optional alignment loss against matched anchor states
    align_loss = modules.verifier_probe(core_B, batch["target_receiver_latent"])

    # Compression penalty
    compress_loss = 0.001 * (np.mean(core_A**2) + np.mean(rel_A**2))

    # Safety penalty placeholder
    safe_loss = estimate_leakage_penalty(core_A, rel_A, scope_A)

    total_loss = task_loss + 0.5 * echo_loss + 0.2 * align_loss + compress_loss + 0.2 * safe_loss

    optimizer.zero_grad()
    total_loss.backward()
    optimizer.step()

    return {
        "total_loss": float(total_loss),
        "task_loss": float(task_loss),
        "echo_loss": float(echo_loss),
        "align_loss": float(align_loss),
        "safe_loss": float(safe_loss),
    }

---

12. Recommended MVP experiment

Here is the simplest research version that could actually be built.

Two-model setup

• same base architecture family
• different random seeds or fine-tunes
• expose middle-layer hidden states

Communication design

• one extracted vector per message
• one type head
• one core vector
• two relation vectors
• linear translator
• memory-bank integration only
• echo verification required

Evaluation

Sender reads a document.
Receiver answers factual and causal questions using only latent packets, not text.

Success criterion

Receiver performs significantly above a no-message baseline and close to a text-summary baseline.

That would prove the protocol carries useful semantic content.

---

13. Failure modes to watch

1. Packet collapse

Compressor learns generic vectors that say little.

Fix:

• harder downstream tasks
• contrastive negatives
• stronger echo loss

2. Overcompression

Too much meaning lost.

Fix:

• increase packet dimension
• add relation slots
• use variable-length packet option later

3. Translator drift

Alignment works early, then decays.

Fix:

• periodic anchor recalibration
• session-conditioned translator
• online adaptation

4. Unsafe hidden leakage

Packet carries unintended sensitive info.

Fix:

• adversarial leakage detector
• scope supervision
• explicit privacy masks

5. Receiver over-trust

Receiver obeys packet too strongly.

Fix:

• trust-gated integration
• advisory mode default
• anomaly-triggered downgrade

---

14. Next-step extensions

After the MVP works, expand to:

• variable-length packet sequences
• multi-packet dialogues
• multi-agent routing
• shared external latent memory
• cross-architecture translators
• tool-mediated latent messaging
• hybrid mode where text and latent packets are both sent

That last one may be especially important. The most realistic future system may use:

• latent packets for machine efficiency
• text summaries for human auditability

---

15. Plain-English summary

A concrete latent communication system would work like this: one model extracts an internal reasoning state, classifies what kind of message it wants to send, compresses the relevant meaning into a structured packet, translates that packet into another model’s coordinate system, sends it, and the receiving model reconstructs and verifies the intended meaning before integrating it into its own reasoning. The whole system can be trained end-to-end using alignment loss, downstream task success, echo reconstruction, and safety penalties.