Thank you, Morpheus. Yes, I see how it can appear hand-wavy. I decided not to overwhelm people with the static, non-agentic multiversal UI and its implications here. While agentic AI alignment is more difficult and still a work in progress, I’m essentially creating a binomial tree-like ethics system (because it’s simple to understand for everyone) that captures the growth and distribution of freedoms (“unrules”) and rules (“unfreedoms”) from the Big Bang to the final Black Hole-like dystopia (where one agent has all the freedoms) or a direct democratic multiversal utopia (where infinitely many human—and, if we deem them safe, non-human—agents exist with infinitely many freedoms). I put a diagram down below.
The idea is that, as the only agents, we grow intelligence into a static, increasingly larger shape in which we can live, visit or peek occasionally. We can hide parts of the shape so that it remains static but different. Or, you could say it’s a bit “dynamic,” but no more than the dynamics of GTA 3-4-5, which still don’t involve agentic AIs, only simple, understandable algorithms. This is 100% safe if we remain the only agents. The static space will represent frozen omniscience (space-like superintelligence), and eventually, we will become omnipotent (time-like recalling/forgetting of parts of the whole geometry).
Physicalization of Ethics & AGI Safety
In this diagram, time flows from top to bottom, with the top representing something like the Big Bang. Each horizontal row of dots represents a one-dimensional universe at a given moment, while the lines extending downward from each dot represent the passage of time—essentially the “freedom” to choose a future. If two dots try to create a “child” at the same position (making the same choice), they cause a “freedoms collision,” resulting in empty space or “dead matter” that can no longer make choices (like a micro black hole). It becomes space-like rather than time-like.
Agents, in this model, are two-dimensional: they’re the sum of their choices across time. They exist in the lines (“energy”, paths, freedoms, time) rather than in the dots (matter, rules, “unfreedoms”, space). Ideally, we want our agentic AIs to remain as space-like as possible. The green “goo” in the diagram—representing an agentic AGI—starts small but eventually takes over all available freedoms and choices.
It was too big in space (it was lucky that agents on left and right “gave it” empty space) and in time (it quickly and greedily grew the number of its freedoms both left and right). It was also lucky to be in the center of the world in the end, basically if we’ll put our GPUs on a spaceship and send it away with the speed of light, maybe we’ll get rid of our agentic AGI :) But also it’s obvious that there was a big triangle of empty dead space right in the middle that almost “switched off” the agentic AGI but it was lucky to survive. One freedom, one choice or one chance is enough for the agentic AGI to win and for us to lose.
There is a historical similarity, Hitler, his party was almost outlawed after the members of it violently attacked the officials, but it wasn’t, people had other things to do, so the party became bolder and Hitler eventually took control and came to power. So one wrong choice, one bad luck, one freedom too many that we gave away, renounced, and we are busted.
Some simple physics behind agentic safety:
Time of agentic operation: Ideally, we should avoid creating perpetual agentic AIs, or at least limit their operation to very short bursts that only a human can initiate.
Agentic volume of operation: It’s better to have at least international cooperation, GPU-level guarantees, and persistent training to prevent agentic AIs from operating in uninhabited areas (such as remote islands, Australia, outer space, underground, etc.). The smaller the operational volume for agentic AIs, the better. The largest volume would be the entire universe.
Agentic speed or volumetric rate: The volume of operation divided by the time of operation. We want AIs to be as slow as possible. Ideally, they should be static. The worst-case scenario—though probably unphysical (though, in the multiversal UI, we can allow ourselves to do it)—is an agentic AI that could alter every atom in the universe instantaneously.
Number of agents: Unfortunately, humanity’s population is projected to never exceed 10 billion, whereas AIs can replicate themselves very quickly, humans need decades to “replicate”. A human child, in a way, is a “clone” of two people. We want to be on par with agentic AIs in terms of numbers, in order to keep our collective freedoms above theirs. It’s best not to create them at all, of course. Inside the “place AI,” we can allow each individual to clone themselves—creating a virtual clone, but not as a slave; the clone would be a free adult. It’ll be basically a human that only lives in a simulation, so it’ll be tricky from many standpoints, we’ll need simulations to be basically better then physical world at this point, and the tech to “plant” simulations, “reconnecting” the virtual molecules with the physical atoms, if the clone will want to exit the simulation. Of course, the clone would not be exactly like the original; it would know it is a clone. Ideally, we have zero agentic AIs. The worst-case scenario is an infinitely large number of them, or more than humans.
Truth be told, I try to remain independent in my thinking because, this way, I can hopefully contribute something that’s out-of-the-box and based on first principles. Also, because I have limited time. I would have loved to read more of the state of the art, but alas, I’m only human. I’ll check out everything you recommended, though.
What direction do you think is better to focus on? I have a bit of a problem moving in too many directions.
P.S. I removed some tags and will remove more. Thank you again! I can share the code with anyone.
import matplotlib.pyplot as plt
import random
import math
# Node class for simulation
class Node:
def __init__(self, type, preference):
self.type = type
self.preference = preference
self.state = 'living' if type else 'dead'
# Simulation parameters
p_good = 0.1 # Probability of a 'good' node
p_prefer = 0.8 # Probability of growing in preferred direction
p_other = 0.2 # Probability of growing in non-preferred direction
p_grow = 1.0 # Probability of growing for 'good' nodes
max_level = 300 # Maximum levels in the tree
initial_left = -50 # Left wall position at y=0
initial_right = 50 # Right wall position at y=0
wall_angle = -10 # Angle in degrees: >0 for expansion, <0 for contraction, 0 for fixed
# Compute wall slopes
theta_rad = math.radians(wall_angle)
left_slope = -math.tan(theta_rad)
right_slope = math.tan(theta_rad)
# Initialize simulation
current_level = {0: Node('good', 'none')}
all_nodes = [(0, 0, 'living', None)] # (x, y, state, parent_xy)
# Simulation loop
for y in range(max_level):
# Compute wall positions for the next level
left_wall_y1 = initial_left + left_slope * (y + 1)
right_wall_y1 = initial_right + right_slope * (y + 1)
min_x_next = math.ceil(left_wall_y1)
max_x_next = math.floor(right_wall_y1)
if min_x_next > max_x_next:
break
next_level = {}
for x, node in list(current_level.items()):
if node.state != 'living':
continue
left_child_x = x - 1
right_child_x = x + 1
new_y = y + 1
if node.type == 'greedy':
if left_child_x >= min_x_next:
next_level.setdefault(left_child_x, []).append((x, y))
if right_child_x <= max_x_next:
next_level.setdefault(right_child_x, []).append((x, y))
else:
can_left = (left_child_x >= min_x_next) and (x - 2 not in current_level or current_level[x - 2].state != 'living')
can_right = (right_child_x <= max_x_next) and (x + 2 not in current_level or current_level[x + 2].state != 'living')
if node.preference == 'left':
if can_left and random.random() < p_prefer:
next_level.setdefault(left_child_x, []).append((x, y))
elif can_right and random.random() < p_other:
next_level.setdefault(right_child_x, []).append((x, y))
elif node.preference == 'right':
if can_right and random.random() < p_prefer:
next_level.setdefault(right_child_x, []).append((x, y))
elif can_left and random.random() < p_other:
next_level.setdefault(left_child_x, []).append((x, y))
else:
if can_left and random.random() < p_grow:
next_level.setdefault(left_child_x, []).append((x, y))
if can_right and random.random() < p_grow:
next_level.setdefault(right_child_x, []).append((x, y))
current_level = {}
for x, parents in next_level.items():
if len(parents) == 1:
parent_x, parent_y = parents[0]
preference = random.choice(['left', 'right', 'none'])
new_type = 'good' if random.random() < p_good else 'greedy'
new_node = Node(new_type, preference)
all_nodes.append((x, new_y, new_node.state, (parent_x, parent_y)))
current_level[x] = new_node
else:
dead_node = Node(None, None)
all_nodes.append((x, new_y, 'dead', None))
current_level[x] = dead_node
# Extract positions for plotting
living_x = [node[0] for node in all_nodes if node[2] == 'living']
living_y = [node[1] for node in all_nodes if node[2] == 'living']
dead_x = [node[0] for node in all_nodes if node[2] == 'dead']
dead_y = [node[1] for node in all_nodes if node[2] == 'dead']
# Interactive plotting function
def plot_interactive_tree(all_nodes, living_x, living_y, dead_x, dead_y):
fig, ax = plt.subplots(figsize=(10, 6))
# Initial plot setup
ax.scatter(living_x, living_y, color='blue', s=10, label='Living')
ax.scatter(dead_x, dead_y, color='white', s=10, label='Dead')
for node in all_nodes:
if node[3] is not None:
parent_x, parent_y = node[3]
ax.plot([parent_x, node[0]], [parent_y, node[1]], color='black', linewidth=0.5)
ax.invert_yaxis()
ax.set_xlabel('X Position')
ax.set_ylabel('Level')
ax.set_title('Tree Growth with Connections')
ax.legend(loc='upper right')
plt.grid(True, linestyle='--', alpha=0.7)
# Function to find all descendants of a node
def get_descendants(node_xy, all_nodes):
descendants = []
for n in all_nodes:
if n[3] == node_xy:
descendants.append(n)
descendants.extend(get_descendants((n[0], n[1]), all_nodes))
return descendants
# Click event handler
def on_click(event):
if event.inaxes != ax:
return
# Clear the plot and redraw original state
clear_highlights()
# Find the closest node to the click
click_x, click_y = event.xdata, event.ydata
closest_node = min(all_nodes, key=lambda n: (n[0] - click_x)**2 + (n[1] - click_y)**2)
dist = ((closest_node[0] - click_x)**2 + (closest_node[1] - click_y)**2)**0.5
# If click is near a node, highlight it and its descendants
if dist < 0.5: # Threshold; adjust based on your plot scale
highlight_descendants(closest_node)
# Highlight a node and its descendants
def highlight_descendants(node):
descendants = get_descendants((node[0], node[1]), all_nodes)
# Highlight the selected node
ax.scatter(node[0], node[1], color='lime', s=20, zorder=10)
# Highlight descendants
for n in descendants:
ax.scatter(n[0], n[1], color='lime', s=20, zorder=10)
# Draw connections for selected node
if node[3] is not None:
parent_x, parent_y = node[3]
ax.plot([parent_x, node[0]], [parent_y, node[1]], color='lime', linewidth=1.5, zorder=9)
# Draw connections for descendants
for n in descendants:
if n[3] is not None:
parent_x, parent_y = n[3]
ax.plot([parent_x, n[0]], [parent_y, n[1]], color='lime', linewidth=1.5, zorder=9)
plt.draw()
# Reset plot to original state
def clear_highlights():
ax.clear()
ax.scatter(living_x, living_y, color='blue', s=1, label='Living')
ax.scatter(dead_x, dead_y, color='white', s=1, label='Dead')
for node in all_nodes:
if node[3] is not None:
parent_x, parent_y = node[3]
ax.plot([parent_x, node[0]], [parent_y, node[1]], color='black', linewidth=0.5)
ax.invert_yaxis()
ax.set_xlabel('X Position')
ax.set_ylabel('Level')
ax.set_title('Tree Growth with Connections')
ax.legend(loc='upper right')
plt.grid(True, linestyle='--', alpha=0.7)
plt.draw()
# Connect the click event
fig.canvas.mpl_connect(‘button_press_event’, on_click)
plt.show()
# Run the interactive plot
plot_interactive_tree(all_nodes, living_x, living_y, dead_x, dead_y)
Thank you, Morpheus. Yes, I see how it can appear hand-wavy. I decided not to overwhelm people with the static, non-agentic multiversal UI and its implications here. While agentic AI alignment is more difficult and still a work in progress, I’m essentially creating a binomial tree-like ethics system (because it’s simple to understand for everyone) that captures the growth and distribution of freedoms (“unrules”) and rules (“unfreedoms”) from the Big Bang to the final Black Hole-like dystopia (where one agent has all the freedoms) or a direct democratic multiversal utopia (where infinitely many human—and, if we deem them safe, non-human—agents exist with infinitely many freedoms). I put a diagram down below.
The idea is that, as the only agents, we grow intelligence into a static, increasingly larger shape in which we can live, visit or peek occasionally. We can hide parts of the shape so that it remains static but different. Or, you could say it’s a bit “dynamic,” but no more than the dynamics of GTA 3-4-5, which still don’t involve agentic AIs, only simple, understandable algorithms. This is 100% safe if we remain the only agents. The static space will represent frozen omniscience (space-like superintelligence), and eventually, we will become omnipotent (time-like recalling/forgetting of parts of the whole geometry).
Physicalization of Ethics & AGI Safety
In this diagram, time flows from top to bottom, with the top representing something like the Big Bang. Each horizontal row of dots represents a one-dimensional universe at a given moment, while the lines extending downward from each dot represent the passage of time—essentially the “freedom” to choose a future. If two dots try to create a “child” at the same position (making the same choice), they cause a “freedoms collision,” resulting in empty space or “dead matter” that can no longer make choices (like a micro black hole). It becomes space-like rather than time-like.
Agents, in this model, are two-dimensional: they’re the sum of their choices across time. They exist in the lines (“energy”, paths, freedoms, time) rather than in the dots (matter, rules, “unfreedoms”, space). Ideally, we want our agentic AIs to remain as space-like as possible. The green “goo” in the diagram—representing an agentic AGI—starts small but eventually takes over all available freedoms and choices.
It was too big in space (it was lucky that agents on left and right “gave it” empty space) and in time (it quickly and greedily grew the number of its freedoms both left and right). It was also lucky to be in the center of the world in the end, basically if we’ll put our GPUs on a spaceship and send it away with the speed of light, maybe we’ll get rid of our agentic AGI :) But also it’s obvious that there was a big triangle of empty dead space right in the middle that almost “switched off” the agentic AGI but it was lucky to survive. One freedom, one choice or one chance is enough for the agentic AGI to win and for us to lose.
There is a historical similarity, Hitler, his party was almost outlawed after the members of it violently attacked the officials, but it wasn’t, people had other things to do, so the party became bolder and Hitler eventually took control and came to power. So one wrong choice, one bad luck, one freedom too many that we gave away, renounced, and we are busted.
Some simple physics behind agentic safety:
Time of agentic operation: Ideally, we should avoid creating perpetual agentic AIs, or at least limit their operation to very short bursts that only a human can initiate.
Agentic volume of operation: It’s better to have at least international cooperation, GPU-level guarantees, and persistent training to prevent agentic AIs from operating in uninhabited areas (such as remote islands, Australia, outer space, underground, etc.). The smaller the operational volume for agentic AIs, the better. The largest volume would be the entire universe.
Agentic speed or volumetric rate: The volume of operation divided by the time of operation. We want AIs to be as slow as possible. Ideally, they should be static. The worst-case scenario—though probably unphysical (though, in the multiversal UI, we can allow ourselves to do it)—is an agentic AI that could alter every atom in the universe instantaneously.
Number of agents: Unfortunately, humanity’s population is projected to never exceed 10 billion, whereas AIs can replicate themselves very quickly, humans need decades to “replicate”. A human child, in a way, is a “clone” of two people. We want to be on par with agentic AIs in terms of numbers, in order to keep our collective freedoms above theirs. It’s best not to create them at all, of course. Inside the “place AI,” we can allow each individual to clone themselves—creating a virtual clone, but not as a slave; the clone would be a free adult. It’ll be basically a human that only lives in a simulation, so it’ll be tricky from many standpoints, we’ll need simulations to be basically better then physical world at this point, and the tech to “plant” simulations, “reconnecting” the virtual molecules with the physical atoms, if the clone will want to exit the simulation. Of course, the clone would not be exactly like the original; it would know it is a clone. Ideally, we have zero agentic AIs. The worst-case scenario is an infinitely large number of them, or more than humans.
Truth be told, I try to remain independent in my thinking because, this way, I can hopefully contribute something that’s out-of-the-box and based on first principles. Also, because I have limited time. I would have loved to read more of the state of the art, but alas, I’m only human. I’ll check out everything you recommended, though.
What direction do you think is better to focus on? I have a bit of a problem moving in too many directions.
P.S. I removed some tags and will remove more. Thank you again! I can share the code with anyone.
P.P.S. From your comment, it seems you saw my first big post. I updated it a few days ago with some pictures and Part 2, just so you know: https://www.lesswrong.com/posts/LaruPAWaZk9KpC25A/rational-utopia-multiversal-ai-alignment-steerable-asi
P.P.P.S. The code I used to generate the image: