Design Node

A Design Node is an independently executable unit of computation.

It absorbs a Signal, performs computation, and emits a Signal:

execute(inputSignal) -> resultSignal

In CPUX, this is where explicit computation belongs.

Black Box, Clear Contract

A Design Node may be written in different languages or hosted in different runtime environments.

What matters is the contract:

absorb Signal
perform computation
emit Signal

The CPUX runtime does not need to know the internal logic of every DN. It needs the DN's Signal contract to be explicit.

Sample Anchor: Move If Allowed DN

A Green Light DN can stay very small.

It receives a Signal, reads Pulse responses, and emits a result Signal:

function execute(inputSignal) {
  const light = readPulse(inputSignal, "current light").response[0];
  const position = Number(readPulse(inputSignal, "current position").response[0]);

  if (light === "green") {
    return {
      intention: { id: "I_movement_result" },
      pulses: [
        { phrase: "movement allowed", tv: "Y", response: ["true"] },
        { phrase: "current position", tv: "Y", response: [String(position + 1)] }
      ]
    };
  }

  return {
    intention: { id: "I_movement_result" },
    pulses: [
      { phrase: "movement allowed", tv: "N", response: ["false"] },
      { phrase: "current position", tv: "Y", response: [String(position)] }
    ]
  };
}

This is sample DN code, not CPUX engine code.

The DN does not know the Visitor, FieldBoard, or persistence internals. It only honours the Signal contract.

Why Design Nodes Should Be Independent

A DN should be testable outside the full CPUX engine.

This supports:

• unit testing
• reuse
• cross-platform execution
• language independence
• AI participation
• safer debugging

The DN should not depend on hidden UI state or invisible global application state. Its context should arrive through the Signal.

The Human As A Design Node

The human can also be understood as a Design Node in the broader perceptual loop.

The human:

absorbs reflected situation
interprets relevance
forms intention
acts
emits a new Signal through the UI

This is not a technical reduction of the human. It is an architectural reminder that the human is an active participant in computation.

AI As A Design Node

An AI model can also participate as a Design Node.

It may absorb a Signal, reason over the Pulse set, and emit a reflected Signal.

The surrounding CPUX structure helps keep the AI contribution bounded by:

• the Intention
• the input Pulses
• the Field context
• the reflected output
• the human-facing result

This makes AI participation more inspectable.

Developer Rule

Keep computation in Design Nodes.

Keep reflection in Objects.

Keep human-facing perception in GridLookout.

This separation is one of the main disciplines of CPUX.