#protocol #language %% Research board on, ![[Protocol Code.canvas|Protocol Code]] %% ![[Protocol Code turns Smart Assemblies into Problem Solving Networks 2024-07-18 15.42.25.excalidraw.png]] %%[[Protocol Code turns Smart Assemblies into Problem Solving Networks 2024-07-18 15.42.25.excalidraw|🖋 Edit in Excalidraw]]%% PROTOPUNKS are a concept I came up while playing [Zachtronics | EXAPUNKS](https://www.zachtronics.com/exapunks/). An EXecution Agent is a small program that can move between hosts without interfering with their processes. The EXA standard is part of the "distributed network programming" vision. EXAs are programmed using an assembly-like language. While, that looks basic at first glance, the ability to run many EXAs in parallel and have them coordinate their actions to solve the various levels is a powerful tool. The only limitation is that, EXAs are mostly used as procedures. Or at least, that is how the game introduces them. Inspired by this setup, I wondered what a `protocol`-first code would look like. And what would be the make up of the entities that run it. The idea of [[You Never Truly Solve a Problem#^e04a0e|PROTOCOL Agents]], as algorithmic smart entities that run on protocol code to deliver continuous problem solving, came to be. The make up of these entities is posited as the simplest reduction of a technological mechano-computational metabolism[^1]. Applicable to any entity capable of [[Worlds with Technological Trees|producing technology]] and whose mechanical and computational activity requires any form of fuel to sustain. [^1]: Humans fall in this category. These entities can load modules and upgrades similarly to how any entity in any world equips itself with tools and aids to conduct various task. When grouped, protopunks form smart networks that enable "signaling code behavior" necessary for the establishment and conduct of protocols. The propagation of signals within a smart network is not instantaneous. Information propagates from one punk to another given that they are within range of exchange. Isolated units form a smart network with themselves and have the ability to signal and read their own signals to establish a feedback loop. Given that, these entities are metabolisms. They must have the notion of a `regime`. A choice of both mental and active configuration that dictates how much fuel it consumes and how long it will last. This configuration reflects a mental model on what is appropriate given the situation, in other words, what type of tools and aids are deemed appropriated. The active component of the configuration refers to the exact choice of tools and their activation levels based on the currently adopted model. A protocol code should be designed around the idea of an OODA[^2] loop as it is the simplest and the most efficient model of continuous decision-making. [^2]: [OODA loop - Wikipedia](https://en.wikipedia.org/wiki/OODA_loop) Protopunk code defines behavior modes, activation regimes (required by various modes), transition rules (between modes) and a dictionary of signals and codes. For a `mode` to be viable, a bare minimum regime is required otherwise the transition fails. Depending on the need, whether be it longevity or efficiency, various regimes can be adopted to adjust the output of the activation and the fuel consumption. When active, a mode keeps looping, with transition checks, running at the end of every cycle. A mode is described a set of activations and signal-code readings that branch into different pathways. These activations apply to modules and transition rulesets which map to action-taking and decision-making. The above relies on the fact that, actions and decisions are signaling and we can use these as codes for appropriate alignment of the protopunk's informational body. %% Do protopunks experience entropy? %% Every punk should have an "Initiation" mode which gives it the "first beat" and starts its activity. It also has a "Failure" mode accessible when fuel reaches a critical level and no regime is viable. Protopunks should be able to communicate with each other through signals that local punks can read and interpret as `code` when possible and adjust their mode of behavior accordingly. Signaling can happen in three modes. A `global` signal is meant to propagate throughout the whole network and be interpreted as code by the relevant units. This mode of signaling is useful for coordination, network management, fault detection and possibly load balancing. A `local` signal stops at the adjacent nodes of the network. Useful for conversational and transaction needs. A local exchange of information that serves purposes like a handshake authentication or more advanced uses like local summarizer nodes, in which a load of signals are consumed by the local nodes and interpreted for the rest of the network. An `internal` signal doesn't propagate at all. It is used as a [[Protocols for Collaboration with our Future Selves|feedback system for internal regulation]]. It is the basis of computation and cognition itself. The ability to signal and read codes is what makes a protopunk, a [[2024-07-14#^8606ed|smart unit]]. As it is, capable of encoding information into its environment and use that as a way to facilitate its operations. Since signals and codes are conventions, each punk has an internal association list. By default, each signal name is the same as the code name. However, obfuscation is possible by associating a new signal name to a code. %% Can protopunks evolve language? %% In a sense, signals are words and codes are meanings. Associations map a new word to some already existing meaning. This feature is key to adaptability and signal evolution beside the obvious security applications. All possible if you just, `associate` one name to another. The association dictionary is accessed every time a signal is dispatched or a code is read. The purpose is to try to translate some ambiguous code into and an understandable signal and vice versa. Protopunks are also algorithmic entities. They leverage a `ruleset` on possible transition and signaling modes to read and write information while problem solving. Rulesets are lists of transitions, prioritized by their order of mention. Each ruleset is uniquely named, and transitions within can be specifically labeled for easy reference. Transitions bearing the same label collectively constitute a rule subset. When deciding on what transition to make, a punk will scan all the rules top-down and transition through the first applicable rule based on a code or the more special case of, a code raised while being in a particular mode. If a rule scan exhausts all rules without activation, the unit fallback to the `default ruleset`. This ruleset operates between cycles to ensure continuous functionality and responsiveness within the unit's operations. A transition rule can outcome into a mode, a regime, a mode on a particular regime, a signal, another ruleset, a subset or a particular transition. Once inside a rule chain, a smart unit will keep resolving until it finds a valid mode or/and regime it can transition to. While having a default ruleset ran in-between mode cycles is necessary for the smart unit to have a way to transition between activations, it is possible to have special rulesets that apply either after or before a given mode's cycle. An interesting consequence of the proposed skeleton language is that, one can view the signal-code design as an API of sorts. The right signal activates a given mode in a smart unit, pretty much like pushing a button. This property enables us to go high-level with metaprotocols. Literally, protocols about protocols. This opens the door a load of possibilities like the ability to handle parallel agents, orchestrate internetwork protocol sequences and emerge new entities like swarms. Protopunks is an idea about a special type of protocol-first algorithms with the aim of producing problem solving agents that can dispatch other agents in their environment, align with them, exploit them and even engineer them. %% Mobile units enjoy the ability to operate under Swarm Protocol, in which case, the swarm becomes its own entity, a problem solving agent in its own rights. Designing the protocol for a whole network like this would be interesting. %% %% The protocol code runs on cycles, similarly to modules which makes it easy to measure efficiency. Also the time of the cycles is computed bottom-up, meaning that the protocol cycle is the aggregation of the modules cycles plus any other logic ... Need to clarify this later. %%