Meeting - demo_wtfisthis

this thing. This is a recording agent. It just goes to our local infra. If you guys don't mind,

I'm just testing out the recording functionality and this might be important to record. Yeah,

I'll just I'll just like implement the what do you call it chilling effect and not say anything

important now. Yeah, so basically not third party, totally self hosted, but also understand

still alien intelligences. So yeah, so basically a task list is a nice easy way to think of this.

So Jeff has a task. Rory has a task. I have a task. Oh, maybe like Jeff and Rory make an

organization together for their shared stuff. And then they start adding tasks to a higher level

task list. In the olden days, or you know, maybe even in Roberto's implement implementation. Okay,

how do we how do we do this? Well, let's spin up a new group to which we can all have accounts

and then add our shared tasks. And when we want to see our shared tasks, we log in there when we

want to see our own tasks, we we go back and log into our other account. And then let's say Rory

and Jeff and I and if Godfrey's here, I'm not sure. But oh, hi. Nice to meet you. Yeah. Oh,

shit. Oh, shit. Not only talking about this. Oh my God, what a moment in time.

Yeah. So in terms of a higher level group, okay, Rory, Jeff, and I, we can throw Godfrey in there.

We all join a higher level group. Okay, we got to mint a new account with a new login age,

with a task list each out with a task list that we all share. And so, okay, we can we can keep

the same underlying structure and go one better and say, Oh, well, actually, wouldn't it make sense

if the tasks can flow down from the top level group to the bottom level. So let's say we have

shared action items come out of a meeting. Some of them are for me. Some of them are for Godfrey.

And some of them are not for Jeff or Rory, but therefore, the organization that Jeff and Rory

made. Oh, okay, the tasks that we make in our shared group can flow down to that second level group.

And then from there, it can flow down to Jeff and Rory personally. So wouldn't it be great

if you can just log into your personal account and then see all of your individual action items

and tasks from all of your groups to n levels of scale without having to mint a new account,

a new data store, run it as a new instance on another server, et cetera, et cetera. So I think

like Jeff has been dealing with some of these issues with R Space as he tries to make the

community infrastructure for how many levels of nesting can I handle? How do I create capability

models and user account controls and all this stuff? And like, how much does it scale?

So Roberto had, I don't know if people have seen his implementation of Hollons,

but there's a nice part of it where you have a globe. And like, I don't know if it's worth

bringing up a screen share because this is a good, let me do it. Yeah, it's good to have a

simplifying model, right? So basically in Hollons, so Hollons are an abstract, it's not a tree

structure, but it's something like that. It's a Holonic structure that have the mappings of spaces

within spaces when spaces, right? This here that Jeff is showing is a geo located version.

So basically it uses what Uber used or maybe even developed for its ability to

break down the surface of the world into smaller and smaller tiles or subspaces.

But what it did that was really smart is it created a geo hashing schema

that creates addresses on each tile. So every, if you go to the highest level,

each tile is a hexagon. Well, most of them are, I think there might be one or two pentagons in

there just to make it work. But each tile is a hexagon, which is broken into seven other hexagons.

Something like that. They don't even map cleanly. It's weird. But for the most part,

it's like it enabled something, right? So each tile is a hexagon, and you go down and you have

a bunch of hexagons underneath that tile, and then you go down one level and you have

more hexagons underneath that tile. So that's pretty cool. That allowed them to

zoom in and zoom out through multiple levels of scale, which is a common problem across

many systems that we're trying to do globally, right?

But what's really cool about it, and I sent Jeff a document about this,

they basically hash, they create an address for the highest level tile. And

the address is like a, you know, a bunch of character string.

But zooming in and out becomes an operation of concatenating

the string. So, concatenating or truncating the string, like cutting letters off it,

or adding letters to it, basically. And so you have an operation that's basically like,

you know, maybe the smallest level tile has the longest string.

Or the, yeah, you know, I would have to actually look at the docs, like maybe I'm

simplifying it, but the way I remember Roberto talking about it was this. And then as you zoom out,

you kind of don't need as many cells, and you don't need as many characters worth of information.

So you truncate the string. And so zooming out is actually a truncation operation,

which is cool, because it's very cheap. And you just...

Can I jump in here? Because this is where it blew up my brain, where I didn't understand

what the difference with H3 was before. I just thought it was in your mapping library or something.

But what it does is it geo addresses. So as Brian said, as you like delete characters from the

address, you're like zooming in or you're moving around. So this is different from like a Google

Maps address, right, which is you send them a URL, like a site address, and then they have to find

some server on the back, or have a server on the back end that says that URL equals this map.

Let me serve that image. That's a lot of computation on Google's behalf, and you need Google.

But when you do it with the geolocation, the intelligence is in the addressing. So the compute

is in the membrane. As you are navigating, you get this, this is fucking cool. So then as Brian

was talking, I was like, well, if we can do this for geographic space, why can't we do this for

semantic space? And I'm thinking like in the verticals of all of the R apps that I've deployed,

because I basically have an R app for every function of like collaboration that I don't know

that I find helpful. And a lot of them just have no tools that kind of exist in that area, like

shared inboxes, shared maps, map calendars, you know, group shopping carts and connected to group

multisig, like why don't these things exist? Why don't why aren't these things easy? So I've been

building R space out of like basically traditional server client relationship this whole time.

And Brian's like, Hey, this is great. But, you know, what would be even better is if we could make

it like, you know, reticulum, you know, so this is another parallel thing, like we've been basically

trying to data quantize and then ZK encrypt and reticulum route all of the data. So we've been

doing that. And now we're talking this addressing system. I'm just like, wait a second, we've just

like quanta quantically chopped up all of the data going through all of the R apps. And now

a space that you and I share can just be a part of our address that hashes together that says you

both shared this space, there doesn't have to be a server that serves a thing that Rory and Jeff

signed into with some authority. It's now all contained in the addressing. And I'm like, wait,

how far can this go? So maybe Brian, you want to come back before I go off into space? But yeah,

well, maybe maybe I'll catch people up then on, I think that's a good point. So

kind of we've had a few cool technologies going on before, but we didn't have the

anywhere anyone getting anywhere close enough to having to implement something

that we needed to mash them together. So maybe so we've got age three. And we kind of know how to

do very cool scale traversal through essentially string operations, simple linear string operations.

And like another another idea, which we'll get to is masking, which is like, you know,

if I have a long string, and it says like, Rory choose, and then I put the number like one zero,

zero, zero, zero, zero, zero, whatever, on top of it, then I can basically say, I don't want to see

all of the last letters like Rory choose, I just want the R, right? So that's applying a mask

on top of the fundamental string to select the first letter, or, or any letter, right? And then

you have more complicated algorithms where you, you know, you mash two strings together and create

a hash or you use an sh to sh a 256 algorithm or whatever to, to mash two strings together

to do operations on it and create a new address, right? So anyway, the point being, you can create

addresses from an existing address. And this is where we get to like, how do we move between

our spaces between cells, between levels of scale and across levels of scale. And do, for example,

this, this nested task list. So I had been playing with the reticulum and reticulum is a mesh network.

And it is quite a nice one, maybe, maybe Godfrey knows a bit about it.

Just since you started dumping in that signal channel for hours on end.

Yeah. So hopefully you're okay with that and up to speed. But yeah.

Cool. Welcome to the fire hose.

No, you love it.

No, Godfrey, are you able to see what's on the screen?

No, I'm not really, I'm trying to select that view and it's not giving it to me.

Try try clicking the tiled view toggle tile view. And then you should maybe see all the screens

like the four squares. Oh, there we go. There we go. Yeah.

So in reticulum, you have a similar looking system where you have a whole bunch of nodes.

It can traverse across any physical link, as long as it's using the reticulum protocol. So

basically reticulum replaces the TCP IP stack. And you can go on the internet without ever being

on the internet kind of thing, which is super cool. But what's the relevant part here? Basically,

every node has an address. And if you want to talk to somebody on the reticulum network,

you need to get their address either out of band or using their announce system,

which propagates the address along nodes. But once you do a key pair exchange,

and you have their address, their routing system remembers the fastest uplink

from you to any other node that you're searching for. And you guys can communicate, right?

But you can communicate in a way that's perfectly forward secret. So all of your packets,

it's not like TCP IP where you get somebody's address. And then,

you know, even if you're using HTTPS or some sort of encrypted pathway,

you're still having metadata from like, who is the sender of these packets? Who is the receiver?

Because the routing protocol needs to know where to send your packets. And so, you know,

your computer is sending out, Hey, I want my packet to get to this, you know, 192.168.5.78

address, if it's local or some other address, if it's on the website.

And yeah, so you're always having to pass metadata, because the routing layer needs to know

where to send your packets. So the ISP can get the metadata, you know, the next ISP can get it.

And then all the corporations that are serving apps or just surveillance capitalism, I mean,

the internet can see who's talking to who. And essentially, even if they can't read the messages,

they can see who's talking. And reticulum solves that in that once you've done the handshake,

the sender doesn't even need to send out who, well, who's the sender. And,

you know, nobody can see even that that metadata that allows you to communicate. Because once the

route has been found, you're all good, right? So I can't, I wrote it down thankfully, but I can't

fully remember at this stage exactly what in the conversation led us to this. But it was basically

like, why don't we take reticulum routing and H3's system of perversing all levels of scale with

geohashing. You know, this is one thing I always wondered about, Roberto's Hollons is like, how

you do you have a schema for creating the address of the Hollons, the next level up Hollon on top of

Jeff or Rory. And you've got the Jeff Rory Hollon. You know, I think what his Hollons is doing is

just minting an address. It's not doing any cryptography between Jeff and Rory's address to

then generate a new address and creating like a Merkle tree, for example. Probably be a good idea

in our case. Yeah, it literally is. So I have things to update you on, Brian. Cool. So, yeah,

basically, you know, just looking at H3 and the amount of computation that's saved by

applying a certain schema to the axis of zoom, you know, you don't have to actually like do some

calculations to figure out how to zoom. You just have created an addressing system that you then

need to just say the address or chop off some letters on a string to choose which cell or

whichever level of scale you want to go to. I mean, that's pretty, pretty amazing, right? So,

let's apply this with reticulum to, to Hollonic addressing. And so I went there. Yeah, yeah.

And add all the extra stuff. So, so basically, before I went to bed that night, I sent Jeff

like also a paper on fractal addressing, which was, you know, if you look at a fractal, the

formalizations, yeah, if you look at a fractal pattern, blanket, you can, you can notice that

certain areas on the fractal look the same as certain other areas if you zoom in and zoom out

or translate across the space, or I guess the manifold one dimensional like two dimensional

manifold or whatever. And essentially, yeah, this person came to a similar conclusion,

which is that with a combination of an addressing scheme and masking, you can translate across

self similar patterns on the, the address tree, let's call it on the, the coordinate system by

applying a mask to some pattern with a function between right. So basically what it looks like is

every Hollon has an address and higher level Hollons, the address is constructed from the

addresses of the lower level Hollons, right. And like actually to be, to be perfectly honest,

masking is like a simple way to think about it. It probably is not using

masking per se, it's probably using some sort of hashing of the addresses. But if you create

any sort of structured relationship between the addresses of the Hollons,

and then you do reticulum routing across those addresses, you can basically translate between

Hollons at any level of scale, and across any layers to other addresses, but you don't have

to do calculations to do it. Well, it's all on the, it's all on the spine or the, the, the access.

So you've embedded, so you've created an address system for how all the Hollons interrelate so

that people can traverse up groups, up, you know, from Rory or Jeff's addresses individually up to

the Rory and Jeff level address, up to the Rory, Brian, Jeff and Godfrey and the AI are in a chat

room level address. But you don't have to create new accounts, post this video chat on a, on a

server for the organization, etc. You just need to provide the address that was made from a hash

of all of our individual addresses put together in some way so that now all of the data, all of the

applications, all of anything related to us as a group of people simply is pointed to another

address on a different level of, of, of Hellonic scale. As Rory, I want to check that you're,

you're with us. Yeah. Sorry, I'm getting a visual on this one. Yeah, that's a good thing. Yeah.

Channel is so use your visual cortex to understand the patterns. We like that. So, so basically

what's very cool about it and the reticulum routing part is

is, yeah, is applying, I guess, how, how do we use this so that

well, yeah, how do we use this to actually navigate between these levels of scale?

So, and, and by, by hashing people's addresses together. So, you know, H3 creates the levels of

scale on an arbitrary axis that allows you to zoom in and zoom out to translate between sort of cells.

But the reticulum part is like, oh, let's create the addresses when two people want to talk

by hashing their stuff together, and then use that for routing. So, basically,

try to visualize this. There's a group at a higher level of scale that was made from hashing maybe

Jeff and my address and then hashing up with your address and hashing that with everybody's address.

So now we've got a character space that is n dimensional.

And movement up and down that character space involves masking

certain characters. But because the character space has been defined already through the

handshakes that people do and through the hashing, we don't have to do computation to route between

the spaces anymore. Like you do that the first time and now you have addresses for where the

spaces are, right? So if I want to go like, oh, hey, I want to look at what's relevant to my address

in this like third level hold on. Well, I just need to provide the address of where that hold on

lives in this abstract space. And because my address in some way is compatible with that address

through a number of hashes or what have you, it already knows that I belong to that group,

because my address was one of the ones that was used to create the group address, right? So

what does this give us? And Jeff can maybe expand upon that. But basically, like, I can

not have to do computation by having a Holonica dressing scheme and know that I am,

I deserve to be in this group. So I have access rights over the data in this group.

My task list should therefore automatically know that any tasks added to that group should flow down

the tree to my personal task account, etc, etc, etc. But basically, we've embedded

the routing logic and the fractal or Holonica structure, dimensional structure

into a character space, which is n dimensional. And using that as an addressing scheme,

we can do mappings across the entire n dimensional manifold, as it turns out,

to be able to create an okay, and this is important. And I might leave out words here

because still getting our heads around it, but we've made an infinitely divisible, infinitely

expansible n dimensional space. So, you know, if you have a Holon and you want to make subgroups

and subgroups and subgroups, your addressing scheme has to allow for infinite divisibility

of the space. And then if you want to make supergroups and supergroups and supergroups,

you need to have infinite expansibility of the space. And then we have a holographic

character space representation of this entire space, which is basically all of the possible

addresses. And we have routing between them based on simply having to look at whether your

personal address or your group address or whatever is compatible with whatever nth level address.

And by creating this space and embedding all of that complexity in the in the axis,

in the character space, you don't, there's a lot of computation saved on conventional models where,

you know, if you're running another server that has to pass messages between servers,

you don't have to do that anymore. Because you just have to kind of know that your address is

allowed in another level address. And that's how you decide access rights. And that's how you know

that you have access to data blocks that deserve to be in that Holonic level. So, essentially,

like, yeah, McLuhan's thing, the medium is the message. And like I gave Jeff some, some analogs

of this, like if you're familiar with other areas in mathematics or engineering,

like Laplace transforms in electronics, you know, you can have really complicated differential

equations that you need to solve. Or you create a new access system in which all of the differentiation

is embedded in the in the axis in the underlying medium, so that if you want to resolve and find

solutions to how to decompose a signal network on a circuit, you only have to do addition and

subtraction and linear algebra type of things now. Right. And you, I don't know, somebody,

Jeff, do you know a really simple example for people who didn't do a bunch of electronics? It's

like, you can all like, you know, polar coordinate systems. So yeah, like an XY coordinate system.

And then you want to do trigonometry on top of it. So like Y equals sine X. And then you have to

solve some like some slightly more complicated things. Or you can check these guys are alive for

a sec. I haven't seen either of them. Oh, just listening. No, I have questions. Right. I've

got vision. This means that, like, I'm not on people and I'm not on whole arms. I'm on like,

we can, we can like map trees in woods. Yeah. Yeah. Yeah. Yeah. And that's what's fascinating

about it because it's an n dimensional manifold that is capable of mapping

any amount of dimensions, any, any type of node also to any level of scale. And then if you provide

enough layers between that. So for example, you want to map one coordinate system on an outer

level of scale to a different type of coordinate system inside another holon. If you provide a

transfer function between them, or there's a name for it in manifolds, maybe an example will help

map between the guys. So the other, the other massively important one for, for my perspective

is the fact that you can then identify the relationship. Right. Yes. Like, yeah. It's

was that the relationship is self aware. Yeah, well, it has like, there's a specific means then

of essentially tagging any given relationship. Yes. And for my specific area of interest is

relational health, right, like relations and being able then to literally tag

any of those relations and that the relation itself can be considered then a unique entity.

Yes. Within that, you need to meet. Yeah. So maybe I'll add the last kind of important

step here. And then we can just zoom out to like, where are we, you know, everybody's brains can

dump stuff. Yeah. So basically, you know, Jeff kind of made an, this is something that like,

I guess needed to be in the pipes for a while, but like Jeff just chucked it all into the

food machine and it came out by the next morning. And then because Jeff then was like also like,

oh, well, you know, we want to do this for the addresses in our space.

What about the data blocks? What about the access controls? What about any number of

basis dimensions that I need? I can define in a holonic way. So okay.

Then it makes all those things the same thing. Yeah. So if I have words,

making bobbleheads. Yeah. If I have words, and then I want paragraphs, and then I want those

paragraphs to all be data blocks in a document. And I want those documents to all be, you know,

pages in a book or something. And I also want them to have access rights across different groups.

Well, I can apply an addressing schema to that, which is the same because it can represent

lots of things at lots of different levels of composition. So basically,

you apply, oh, it turns out to be the same pattern, but you just give it another dimension,

which is the data dimension. And then every data block has an address at a certain level of

scale. And then so you have this in your set, and you decompose your system into like how many

basis dimensions do I need? And I can't really remember, Jeff, but it's like I need access rights,

I need addresses for the spaces I need. Bye. Yeah. And so now you have like your anything that needs

to be represented in your system now has an address representation across dimensions. And you can

traverse this space without having to send any messages or do computation.

Yeah. That's cool. Yeah, that's pretty nice. And yeah, so let's all just take a moment

and like be happy about that. But the other side of it, I guess, to reground it in like why is

reticulum important is, you know, this is like we want a world of agent centric computing with

where agents hold their own data and choose when to forward that rights on that data to the network.

And this is where Godfrey and ZK come in, right? Like, you know, and I want to just be able to show

proofs that I have certain requisite data or to validate certain things without having actually

show my data. So maybe Jeff, because I wasn't so clued in, I was more focused on the addressing

scheme, but Jeff has been implementing ZK in our space for some time. So how does this bring in ZK?

I mean, every data packet is ZK encrypted. It's just like, so they're like, it's the perfect

encryption every and, you know, Godfrey, I don't know, maybe you have some technical input on

where ZK and reticulum fit together. But I mean, every time I give a repo to the AI, it's like,

this is a exact match. This is the mathematical formalization. This is the technical formalization

of the routing. This is the formalization of the ZK. Yeah, I will say, I forgot to say one last bit.

So the reason this is nice is so moving away from client server, mental models, and this is going

to be a bit of a process. Like every time we come back and look at this, you know, if you're not

familiar with Holochain or something, it takes a little while to just start thinking in a membrane

computing style way. But basically, in reticulum, the design is for a network that maybe has

like low bandwidth up links between nodes. It's not like the internet where people have like focused

on this massive build out a very high bandwidth infrastructure so that you can stream cat videos,

you know, from Antarctica, which are living on a server in the US. Reticulum actually is solving

a problem. I found a good article that I forgot to share that was basically NASA had tried to figure

out how they could do a mesh networking system that could handle very low bandwidth up links and

really long round trip times on the data so that you could get to some ship in outer space like

three minutes later, and it's not going to be like connection, you know, unclear, like drop the link,

it's going to be like, okay, data takes time to travel. And reticulum has that, right? Because

you're going between high bandwidth up links and then allora node, which can transmit at like

one kilobyte kilobit per second. And so basically, you have to do your applications in a design

way that's called store and forward, right? So each node might run the same application.

So rather than have one server running the application and then like bandwidth is free,

you know, let's send data chunks to everybody. Well, a, we don't need to do that because we don't

want to be having to calculate a lot of things and send things across the network.

So this is where like Holochain had already figured this out, right? Oh, well, why don't you run the

application and only have it have to see data and stuff that's relevant to you, right? So you can

run the application on your node and only, and yeah, maybe you have to get some data from another

nearby node or a couple of hops away or something. I'm going to like make, make a, a race, a system that,

that helps you understand that the data that's shared between all your peers at your level of scale

is not being, you know, tampered with. And that's why, you know, that's just borrowing blockchain,

but it's having chains of chains of chains at any level of scale, right? But also we're going to

make sure that the application code that you're running is being verified. Because even if you're

sharing the same data with people, but a couple of nodes band together and run a fake version

of the application that gives you more money than all of your friends, then we want to actually

check the application code. So Holochain is Holonic, but it didn't implement anything like

Holonic addressing. It's, its main purpose is to show that data is verifiably consistent across all,

all levels of scale, right? So yeah, with reticulum, you're coming, let's just ground it in the real,

well, and not just with reticulum with this system, you're coming and you're coming with your own

node and your own application set running on your node. You hold your data, but you're forwarding

it to the network based on whom it's relevant to share it with. But this is where it gets interesting.

You're forwarding it up to whatever level of scale in the holographic character space

that matters to you based on whomever you want to share it with. And when you're sharing it,

you're sharing it at ZK encrypted. So yeah, that, that's kind of like, where does the rubber

meet the road? Like how does this look for a person? So you don't have to spin up a new server

for an organization. You don't have an organization is just you guys choosing to share

to a different level of access rights on the addressing schema, your data. And then that address

now lives in this holographic space. And so if you want to make a group with people, well, just

you gotta, you gotta access that address, right? And there's a whole bunch of stuff that I still

don't even know what Jeff has implemented. Like, how do you add people to a group? How do you

delete people from a group? Do you have to change the address somehow or whatever? But then, you know,

then we're starting to talk about like, and K and n graphs and like nearest neighbors and graph

summarization and all this stuff that I guess we've been adding on top and still trying to wrap

our heads around as we go. But I think you've got the basis stuff now and then other other layers

that we can add to this like some of the, I guess use cases that Jeff and I ended up then talking

about including, you know, internet naming system, which is why I want to talk with Jeff, like, how

do you do a holo holonic namespace instead of a global namespace? How do you do what was the one

we were doing like yesterday on the day before? I feel like we've done some pretty cool things,

but I can't remember what they are anymore. We're just shitting unicorns these days, like every night.

Another unicorn just comes out accidentally, accidentally. It's like, oh, you get all this

shit for free. Oh, you know, you were going to do all that stuff turns out it's all one thing.

And actually, we can just do it now. And it's like, it just simplifies everything for everyone

forever. And it's like, what the what the what? Yeah, well, yeah, go on godfrey. It's time to

brain dump. I think we got a simple questions and reflection and review. So basically, as above so

below, it sounds like where your note is, you have internal connections, and then you have

external connections from what I was understanding. In like your membrane, then there's membranes above

you membranes below you that you're already connected to. And then you want to reach out

and connect to the other. There's a few questions I have around. What are the like, what's the node

discovery? Is there some kind of like you were sharing earlier? I mean, I'm trying I'm working

to track all this and then have potent output here. So like in the ways of discovery, once

you're already connected, is there a way to map? And then what's the permissions around the external

nodes and internal nodes that secure you locally? And then there's a way to, I guess, to verify.

It's all about this very verification from you to other nodes to the, I guess, the greater fractal

holons and the greater internal holons, if that makes sense. And what was the, can you just repeat

what was the question there? What is the discovery was the first one and then second one was?

The second one was, I guess, it's the mapping of the discovery and understanding the permissions

of these connective, the connective tissue for the membranes. Like, what's that verification

process? Yeah, like, how is it hashing? Is it masking? Like, how does it know that you should

be allowed to traverse this address space in this way? Yes, exactly. Well, so the first thing I want

to triply, doubly make sure of is we're not talking about physical nodes. So like, yeah, it gets a

bit confusing. We're talking about using reticulum, right? And it has its own system of announcers and

finding other addresses and then making a handshake with them and all this kind of stuff.

We're talking about on the application layer above that, that can be integrated with your

physical node address, right? But we're creating a holographic space that is not on a mesh network.

For example, it's in the application space above the mesh network, right? Okay, that makes sense.

Yeah. But it could also be the addresses on the mesh network if you felt like it made sense that

the physical links are representations of the agents, but probably not, right? So yeah, as for,

and this is where I think I want to reframe this as a question, answer thing. Like, and we are missing

some key people in this room. So this is not happening in the usual thoughtful way of, let's

take our time to really know what's going on and only then implement the next step. Like, that would

be my preference, but Jeff doesn't listen to me. And so it's really happening at the speed of

intuition going through the AI and then us catching up to like integrate, make sure we can explain it

in physical conceptual language. And then so what we're doing is we're setting up an auditing pipeline

right now on being able to be like, here's all the features that have been implemented so that you

have a map to come through and audit this step by step and understand. So I can't actually tell you

the answer to your first question. I can't like what is the hashing algorithm used to create the

new addresses? What gives addresses permissions? Ede 5519 or something like that. Yeah. Yeah.

So I mean, there's not more about the implementation side. Take it away. Yeah.

I think the shortest way to give the answer would be co homology. Like, like what Brian said,

actually, which I think is a really neat way to say it navigating an n dimensional space with no

computation. So it's all in the address. So like, I feel like there is some magic in the way that

ZK and reticulum and this like mathematical formalism of these, these that Brian sent me,

it was just like, actually, this is perfect, we can have, you know, discovery through the shared

shape of a hashed address space. So like if you and I share, like, we don't have to make a third

space that is the ZK and space, it can just be a space that you and I share in our addressing.

So in that way, it's like the discovery is kind of like part of like, it comes with just turning

on your discoverability. Like if you want to be seen, everybody with that similar shape

can see you. But people without that similar shape can't see you and the people that can see you,

they don't necessarily know anything about you because it's all zero knowledge. They just know

you're a similarly shaped thing. That might not even be a human. Like it might be a package

communicating with another package, or like a package communicating with a driver in a

decentralized mail system where the package knows it needs to get from here to there and it searches

for the shape of the trip of someone who might be going that direction. Yeah, so that's actually,

I remember the email you sent that was about, like we were talking about, oh, how do you do a system

where if you lose your key, you know, like what is it? Sameer's secret sharing stuff. But instead of

kind of nominating three people that you need to like reconstruct your key, if you lose it,

how do we end dimensionalize this? And it's like, well, what if by default, everyone you interact

with, like your past interactions across this network and between agents and on the network

space, that gives you a fingerprint in a space that people can't see because it's all ZK.

Yeah, and is there a time? Yeah, that's amazing. Is there a like a time expiry so you don't drag

around all your past? Maybe we're doing some testing here. There's a way, like auto opening.

Yeah, so this is where turn your question into a, this sounds like a good idea.

And let's improve the model. No, I love this intuitive approach. Absolutely. Adjusting.

Yeah. Yeah, so exactly. So it's like, okay, we, and we've done this on a few iterations, right?

Jeff keeps like fucking putting the card before the horse and I have to like get on my donkey and

catch up. It'll be done by the time we understand it. Yeah, I love it. But basically, yeah, so, okay,

so let's implement some, so it turns out that the K nearest neighbors thing then becomes a

functionality that becomes useful across every other dimension, right? So let's throw that in there.

What else? Like there's some core bits that like as we go and like,

yeah, just, I think it was yesterday and I really want to know if Jeff picked up what I was putting

down on the, on the global name space. Like this, this is a fun example. I just want to talk about

it. Like right now, okay, no, we're skipping too many steps. Like, then we were like, okay, if we

want to deploy our space, we need to be able to access web apps. If we want to display deploy our

space on reticulum, we need to be able to access web apps on the reticulum network. Now reticulum

has something called NomadNet, which is it's not using HTML or HTTP. It's using, I can't remember

the name of it, some like very low brow, like some very data, like it, what's the opposite

of data hungry? It's very efficient with how you can serve pages on NomadNet. It's a different

protocol. But then somebody made something called mesh web, which allowed you to serve HTML website.

Over reticulum. Yeah. And then Jeff started to be like, oh, I want to have a website I can

serve that is accessible both by people over the reticulum network and over the regular TCP

IP system by going to the same address. And then we got to a point where it's like, well,

you want to have self aware routing so that people know because like Jeff did this thing

where the page actually said like, you are not on the internet, you know, you're, you're accessing

this web page over reticulum. But then I accessed it, but I knew that my reticulum network wasn't

working. And it still said that I was seeing it over the, not the internet. And then so we

realized, oh, you actually want your data packets. No, that that's skipping a step. You actually just

want to know as an end user, yeah, which, which network did I access this over? But it turns out

that because of the way we implemented this substrate, your data packets themselves because

they bounced through an address space have awareness of the medium through which they're

traveling. And so the packets are self aware as to whether they ever pass through TCP IP space,

or whether they stayed in reticulum space. And this probably has implications across every other

dimension that we haven't even bothered to think of yet. But it's like, all of your data is has

self aware routing, like anything through the end dimensional space can have path awareness.

And then Jeff started thinking about postal systems and all this kind of stuff.

It goes and it goes and it goes. So what was, yeah, that's incredible. Brian was like looking to

HNS handshake. So I was like, okay, I fed it HNS. And it was like, Hey, this would be useful for like

this one thing. And I was like, wait, isn't that useful for like everything if we just

halonify it? And it was like, Oh, my God, you're right, we could halonify this too. And I'm like,

can you add it into the Janus addressing? And it was like, of course we can. And I'm like,

I think because with the cannon grouping, like, and the the basically like,

so give us okay, go on and then we'll jump back to this. Okay. From HNS, rather than just having

a handshake agreement, basically, it said, if you want to use this, there are a lot of kinds of

handshake agreements, there might be like simple direct ones where I have X and you need X, there

might be ring ones where I have a and want B, you have B and one C, you have C and you want A,

then you may have more even more complex ones where there are multiple dependencies, multiple,

you know, and you have large stakeholders. So it was like, well, how are we going to compute

this? And I was like, how about we don't compute it? How about we treat all of these handshakes as

part of the addressing thing to at the individual level that then nest holonically. So your your

commit your intense so intense or a mathematically formalized, like basically solver system for

stuff in anything you intend in a network. So that's already in, we've already done an OMA.

Now we've got basically reticulum routing and the context aware packages at every point in the

network. So basically, it went from saying this is computationally irreducible, like we cannot

build a system. And I mean, that makes sense. How are you going to like measure all of the things

across all of the scales? But then it's like, wait, what if every package in that halonic infinity

knows where it is, knows where it's from, where it's going. And then it only has to deal with

its local like KNN. And it was it was basically like, okay, in small networks, you get a 7000x

improvement in efficiency network efficiency. In large networks, it was into the billions or

hundreds of billions of times more efficient, basically, meaning this can be computationally

tractable at a halonic level, which could like, I mean, I'm like, what the fuck, what does that mean?

So, yeah, I don't even, I don't even know what we're playing with at the moment,

but it's being filled and it'll be done by the time we have any clue of what it can do.

So it sounds like, yeah, Jeff took the handshake thing with an OMA.