►
A
A
A
I
think
I
think
you
all
understand
why
I
so
desperately
desperately
want
us
to
have
distributed
compute.
I
can't
I
can't
maintain
computers
for
the
life
of
me,
so
it
better
be
easy
to
move
one
thing
from
one
computer
to
the
next
computer
because
they
don't
stick
around
for
long.
Okay,
is
this
working
all
right,
great,
all
right?
That
is
going
the
other
window.
A
A
A
A
A
A
A
B
A
A
A
A
Okay,
of
course,
robust
mechanisms
for
secure
communication
already
exists.
However,
most
rely
on
key
registries,
identity,
prover
providers,
certificate
authorities,
browser
app
vendors
or
similar
centralizations.
Many
are
unsaturated
or
many
are
unstructured.
Rich
chat
only
or
enable
value-add
behaviors
through
proprietary
extensions.
A
A
A
Alice
wants
to
negotiate
with
bob
to
sell
something
online
because
d-I-d-com,
not
direct
human
communications
methodology
in
this
example
alice's
software
agent
on
bob
software
agent.
This
is
exactly
what
we're
saying
are
going
to
exchange
a
series
of
messages.
Alice
may
pay
just
press
a
button
and
be
unaware
of
the
details,
but
underneath
her
agent
begins
by
preparing
a
plain
text,
json
message
about
the
proposed
sale
particular
sign
of
irrelevant
here,
but
would
describe
as
a
spec
of
a
higher
level,
sell
something
protocol
that
uses
the
iq
column
messaging
as
its
foundation.
This
looks
perfect.
A
Alice's
agent
then
gets
two
key
pieces
of
information
from
bob
typically
by
resolving
bob's
did
doc
an
endpoint
where
messages
can
be
delivered
to
bob
perfect
if
public
key
the
bob's
agent
is
using
in
the
alice
bob
relationship
perfect.
Now,
alice's
agent
uses
bob's,
qd
and
crypto
plain
text.
So
if
anybody
got
roped
into
chill
chat,
if
I
roped
you
into
chill
chat,
this
will
sound
familiar.
A
A
A
I
think
what
did
I
come
down
to
yeah?
I
think
I
came
down
to
the
fact
that
you
needed
attestation,
because
how
am
I
supposed
to
trust
your
node
to
relay
my
rest
message?
Yeah,
that's
what
I
came
down
to
yeah
and
so
that's
what
we're
talking
about
with
the
with
the
review
system
and
then
the
yeah,
the
attestation
and
the
attestation
is
basically
you're
proving
that
you're
running
on
what
you
say,
you're
running
on
and
then
now
we're
also
talking
about
running
basically
sandbox
code.
A
A
Basically,
and
that's
what
they're
saying
that's
what
they're
saying
is
is
is
is
there's
projects
like
our
project
right
now
who
we
want
to
use
this
so
two
years
ago
we
did
a
gsoc
project
to
do
distributed
server
with
with
nats
a
distributed
setup
with
nats,
and
we
didn't
we.
We
didn't
know
enough
about
how
this
should
work
then,
and
so
a
lot
of
great
stuff
got
done,
but
at
the
end
of
the
day
we
didn't.
Quite,
I
think
we
we've.
A
A
Because
we
want
to,
you
know,
be
able
to
host
things
on
our
own
machines
and
be
like
hey.
You
know,
try
this
new
little
model
that
I
wrote
right
or
try.
You
know
whatever,
and
and
so
that
we
can
all
hack
together
collaboratively
remotely
right,
but
you
know
it's
very
hard
to
do
that
when
you're,
like
you,
know,
you're
trying
to
share
your
application,
you
know
with
somebody,
maybe
so
so
what
what?
If
you
wrote?
What
I
had
one
earlier
like.
A
You
know
you
write,
you
write
a
cool
little
you
you
just
write
hello
world
right,
but
you
should
be
able
to
deploy
hello
world.
You
know
to
your
grandma's
iphone.
If
you
wanted
to
right,
like
you,
should
be
able
to
do
that
by
sending
her
a
it,
it
shouldn't
be
hard
to
make
it
say
like
to
do
the
same
thing.
You
know
that
you
would,
if
you
have,
if
you
have
these
predefined
relationships
of
trust
in
the
real
world,
to
then
extend
them
to
the
digital
world,
and
then
you
know
sort
of
extend.
A
A
In
this,
like
mesh
giant
distributed
mesh
network
of
whatever
computer,
we
can
get
access
to.
We
we
can,
you
know
we,
we
don't
have
to
jump
through
a
lot
of
hoops.
We.
Basically,
if
we
want
to
proxy
you,
you
write,
you
can
write
anytime,
you
want
to
get
data.
Basically,
all
of
the
data
travels
between
nodes.
Through
this
you
know
web3
interface
or
wait.
Do
we
really?
Even
now,
I'm
actually
thinking
about
this
again.
A
A
A
A
This
is
the
world
of
open
api,
swagger
and
most
rpc
for
that
matter,
and
it
has
many
virtues.
Unfortunately,
many
agents
are
not
good
analogs
to
web
servers.
They
may
be
mobile
devices
that
turn
off
at
unpredictable
intervals
and
lack
stable
connection
in
the
network.
They
may
need
to
be
work
peer-to-peer
when
the
internet
is
not
available.
They
may
need
to
interact
in
time
frames
of
hours
or
days
now
with
30
second
timeouts,
and
we
listen
to
the
same
channel
that
they
used
to
talk.
A
So,
if
you're
interested
in
doing
embedded
device,
development
and
stuff
like
that,
this
is
like
you
know.
Maybe
you
know,
building
building
these
protocols
into
the
low-level
drivers
on
on
some
of
these.
You
know
resource
constraint,
devices
in
yeah,
in
protocols
like
rus
or
in
things
like
rust,
would
be
some
some
cool
projects
or
you
know,
into
existing
projects
that
are
written
in
whatever
language
they
already
are
and
to
add
support.
A
Something
like
zephyr
would
be
really
cool
to
add
this
to
so
because
of
this
fundamental
paradigm
of
ddi.d.com
messaging
is
message
based
asynchronous
and
simplex.
Alice's
agent
sends
message
over
channel
a
sometime
labor
later
it
may
receive
a
message
which
may
or
may
not
be
a
response
from
bob's
agent
over
channel
b.
This
is
much
closer
to
an
email
paradigm
than
a
web
paradigm.
On
top
of
this
foundation,
it's
possible
but
elegant
synchronous,
request
response
interactions.
All
of
us
have
interaction
with
their
friends
god.
This
is
just.
A
A
A
It's
distributed
well,
okay,
but
I
don't
trust
them
when
this
information,
you
know,
if
you
can
break
these
keys
20
years
from
now,
then
I'm
not
sure
that
I
trust
them
random
people
to
relay
stuff
for
me
and
that
was
kind
of
the
the
conundrum
that
I
ran
into.
You
can
set
things
up,
obviously,
but
everything
at
the
end
of
the
day
ends
up
being
like.
A
A
B
A
Okay,
oh
sorry,
the
id
com
messaging
is
a
powerful
way
for
people,
institutions
and
iot
things,
internet
of
things,
things
to
interact
via
machine,
readable
messages,
using
features
of
decentralized
identifiers
as
the
basis
for
security
and
privacy.
It
works
over
any
transport,
http,
bluetooth,
smtp
raw,
socket
sneakernet,
for
example.
I
don't
know
what
sneakernet
is,
but
I
know
what
smtp
http,
bluetooth
and
raw
sockets
are,
and
I
like
that.
It
works
over
all
of
them
and
is
that
it
is
that
it.
What
is
this
hyperledger?
B
A
Why
why
okay?
I
am
questioning
why
I'm
doing
this,
though,
because
I
think
maybe
I
should
just
implement
the
data
flows
class
stuff.
Okay,
I
think
we
decided
that
yes,
this
is
a
valid
way
to
go.
We
haven't
okay,
we
haven't
been
able
to
put
a
system
context
in
there
yet
so
we
need
to
know
that
we
can
put
a
system
context
in
there
if
we
can
put
a
system
context
in
a
message.
A
A
A
A
A
A
A
A
Okay,
let's
use
this
one,
here's
this
guy,
this
guy's
put
some
stuff
on
here
and
he
was
on
the
one
that's
active
recently,
which
is
this
one
there.
He
is
so
because,
and
so,
once
again
we're
building
these
we're
building
these
these
graphs
where's
where's,
who
are
the
key
players
who's
involved
in
what
projects?
How
do
you
know
you
need
to
understand
who?
What
what
code
bases?
Do
you
trust
and
what
people
can
you
trust?
Who
wrote
those
code
bases
what
base
or
and
what,
like
things,
based
on
what
stuff
you're
seeing
like
on?
A
You
know:
you're
looking
on
twitter
and
you're
like
okay,
so
we
see
that
you
know
this
guy
daniel
he's.
Obviously
he
knows
he
knows
what
he's
talking
about.
We
should
go.
Listen
to
him
right
this
guy.
He
seems
to
be
another
another
smart
daniel,
so
we
need
to
go,
listen
to
him
and-
and
so,
if
he's
working
on
this
one,
if
they're
keeping
this
up
to
date,
that's
a
good
sign.
A
It's
getting
updated
like
somebody's
working
on
it.
It
looks
like
there's
a
working
group,
we
could
join
oh
and
they
have
slack
channel
okay,
so
we
can
go
check
that
out,
but
not
right
now,
okay,
so,
but
for
now
we
know
that,
basically,
okay,
so
by
association,
we
can
sort
of
trust
that
this
is.
This
is
good.
This
seems
like
good
stuff
right
here.
You
know
like
this
is
stuff
that
we
can
build
build
stuff.
A
A
A
A
A
A
A
B
A
A
B
B
A
B
B
A
B
A
Are
they
in
here?
I
think
they're
defined
here,
yeah
they're
defined
here,
resolvers
config,
okay,
here
we
go
so
this
is
what
we're
doing
secrets
resolver
I'll
ask
to
see.
This
is
why
I
really
hate
this
from
pi
test
and
why?
But
it's
nice
that
pi
test
does
this,
because
this
is
a
data
flow
based
approach.
So
it's
going
to
be
very.
It
should
be
trivial
to
extract
this
information
from
pi
test
and
and
it's
it's
it's
basically,
it's
it's.
It's
internal
data
flow.
That's
keeping
right!
So
that's
going
to
be
great!
A
B
A
B
A
A
A
B
A
B
A
A
And
referencing
verification
methods
allows
them
to
be
used
by
more
than
one
verification
relationship.
It's
like
a
ref
or
something
or
it's
like
a
yeah.
It's
like
one
of
those
json
schema
refs.
If
the
value
of
a
verification
property
is
a
map,
the
verification
method
has
been
embedded
in
its
properties
and
can
be
accessed
directly.
However,
if
the
value
is
urls
string,
the
verification
method
has
been
included
by
reference
and
its
properties
will
be
needed
to
be
retrieved
from
elsewhere
in
a
did
document
or
from
another
did
document.
A
I
don't
think
this
throws
wrenching
anything
for
us.
I
think
we'll
just
sort
of
take
it
as
face
value
and
say:
okay,
cool
the
following
curves
in
our
in
grand
prize
supported.
Okay,
great.
This
is
where
we
asked
matt
thanks
forward
protocols
implemented.
Okay,
you
gotta
have
crypto
getting
gotta
gotta,
find
a
crypto
person.
Gotta
find
good
math
people
crypto
people.
A
B
A
A
Okay
looks
like
this
is
from
the
last
stuff.
He
did
well,
he
might
have
been
making
bow
loads
of
money
yeah
and
then
he
just
might
have
stopped,
because
that
is
what
I
just
advocated
for
so
and
good
on.
You
dude,
sweet,
okay.
Well,
we
won't
bug
him,
then
he's
probably
just
chilling.
Then
I
think
we
can
just
assume
that
he
kind
of
cashed
out,
because
this
is
just
fantastic.
A
A
A
A
A
A
We,
if
you
think
about
like
sort
of
there's
different
problem
spaces
right
and
you
know
people
are
working
within
those
problem
spaces,
and
this
is
where
we
we
talked
about
like
the
w3c
and
rcfs
and
our
rfcs,
and
you
know,
then
the
adrs
within
the
individual,
repos
and
sort
of
how
you
know
like
adrs,
then
w3c,
then
rfc
or
like
you
know,
but
this
is
the
widest
widest
reach,
because
it's
all
of
the
internet
right
and
so
what
we
did
is
we.
We
said
we
need
this.
A
A
Deployment
environment
and
there's
people
working
on
this
type
of
stuff,
of
course
right
this,
I
think
I
saw
I
think,
zelenka
brooklyn
zelenka,
I
believe
she's
her
company
looks
similar
to
this.
I
saw
it
but
heavily
based
on
elixir.
It
looks
like
they're
doing
some
really
cool
stuff
there
and
yeah,
so
this
is
this
is
definitely.
A
And
alice
is
just
obviously
you
know
the
the
instance,
the
name
for
the
instance
of
the
entity
and
so
any
any,
and
like
any
instance
where
you
run
it,
you
can
name
it
whatever.
You
want
right,
like
so
so
great
so
yeah,
so
so
our
alice
is
going
to
be
our
our
bot
for
our
project,
and
so
because
we
had
talked
about
spinning
up
infrastructure
and
stuff,
and
so
basically
we're
just
going
to
wrap
all
that.
A
As
you
know,
developers
on
our
project,
where
we're
very
geographically
distributed-
and
you
know,
maybe
have
different
hardware
and
different
problems
on
different
hardware
and
and
just
different
systems
and
configs
and
stuff,
and
so
if
we
can
communicate
those
environments
right.
If
we
can
take
snapshot
these
system
system
contacts,
we
can
then
begin
to
eliminate
the
it
works.
On
my
machine
or
the
it
doesn't
work
on
my
machine
problem
right
because
we
can
say
well.
Why
is
your
machine
different
than
some
other
machine
right
right
now?
A
We
don't
know,
but
we're
going
to
find
out
right
because
we're
going
to
capture
state
and
we're
going
to
capture
overlays
on
on
upstream
and
and
and
just
we're
going
to
capture
a
lot
of
state
basically
and
then
we're
going
to
put
it
in
this
in
this
web
3
network
and
likely
what
we'll
do
here
is
so
what
we're
seeing
here
is
so
bob
and
alice
are
passing
messages
to
each
other
right
and
in
the
event
that
we
are,
you
know,
maybe
doing
a
method
call
within
a
data
flow
execution.
That's
distributed.
A
I'm
publishing
my
new
change
right
and-
and-
and
you
know
you
can
also
have
these-
you
could
have
the
basically
the
nice
part
about
using
this.
This
web3
message
bridge
is
that
now
we
can,
we
can
take
any
service,
anybody
can
stand
up
a
service
anywhere
and
it
doesn't
have
to
be
connected
to
http.
You
don't
need
a
website,
you
don't
need,
you
can
run
stuff
in
webassembly.
You
can
run
stuff
in
your
browser
because
we're
going
to
pass
it
all
through
this
right,
and
so
you
don't
need
to
maintain
servers
anymore.
A
You
can
run
your
stuff
in
in,
like
you
know,
base
anything
that
runs.
Wasn't
you
can
run
your
stuff
right
and,
and
what
is
your
stuff
well,
your
stuff
is
defined
by
these.
These
these
system
context
these
data
flows
that
are
living
in
at
least
their
their
very
most
basic
form
where
they
go
and
get
the
rest
of
the
data
that
they
need
on
chain.
A
B
A
A
Sometimes
sometimes
it's
like
when
I
it's
like:
oh
man,
it's
still
good.
It's
still
good.
It's
still
good
still
making
progress,
but
it's
just
it's
better
to
have
the
recording,
because
I'm
talking
to
it
and
not
writing
it
down,
which
saves
time.
Obviously
it
also,
you
know,
takes
time
to
explain
some
things,
but
it's
good
to
explain
things
because
we
need
to
get
this
all
written
down
of
the
whole
process
right.
A
A
A
B
A
A
A
Also,
putting
the
upstream
url,
where
you
got
the
source
from
this,
ensures
that
you
can
double
check
very
easily,
that
that
is
the
license.
You
think
it
is
and
because
you
don't
want
to
run
down
the
line
and
realize
you
actually
switched
the
wrong
tab
there
and
which
is
actually
now
I'm
going
to
do
it
again
to
double
check
and
it
is
apache,
2.,
okay,
great
yeah,
you
don't
want
to
you
don't
want
to.
You,
do
not
want
to
be
down
the
line
and
and
using
the
wrong
license.
A
Okay!
No!
So
now
we
have
to
do
secrets,
resolver
alice,
all
right,
okay,
just
keeps
coming
just
keep
coming
see.
This
is
why
this
is
why
we're
gonna
get
the
data
flows
and
we're
gonna
get
it
so
that
we
can
introspect.
John
was
already
doing.
White
man
was
already
doing
some
python,
ast,
parsing
and
so
we're
gonna,
and
I
mean
this:
is
you
don't
even
need
to
do
ast
parsing
for
this
right?
You
just
you
just
load
all
the
files?
A
A
We
just
once
we
get
this
once
we
get
this
solid
foundation
down
where
we
get
this
sort
of
one
level,
always
one
level
deep
execution
like
the
kvm
nested
setup,
then
it's
gonna,
be
you
know,
I
think
I
think
basically
we'll
we'll
be
ironing
out
documentation
and
auto
ml
stuff
and
because
the
current
stuff
that's
in
there
was
probably
like
the
least
performing
way
you
could
ever
possibly
do
something.
I
think
we
have
some
some
some
basics.
A
Obviously
this
is
why
you
know
it
takes.
It
takes
everybody
to
figure
it
out.
So
I
think
once
we
get
this
distributed
to
compute
down,
that's
gonna
make
a
lot
easier
to
interact
and
and
and
once
we
get
this
sort
of
you
know
things
we
we
get
this
data
flow
as
class
and
we
get
the
data
flow
as
class
down,
and
then
we
do
the
yeah
we
get
the
data
flows
class
down.
A
I
think
that's
going
to
be
really
good.
I
think
that's
that's
going
to
be
we're
gonna
be
in
a
good
spot
there
and
then-
and
then
you
know
also.
Maybe
we
also
just
need
to
do
like
introspection.
You
know.
Maybe
we
could
do
it
where
we
look
at
a
pie
test
test
and
we
enable
running
it.
Maybe
we
should
do
that.
That's
actually
really
good.
That
could
be
a
really
good
course
of
action.
A
You
know
rewiring
of
things
so
because
your
data
flows,
your
intermediate
representation.
That's
that's
the
cross
language.
Intermediate
representation
focused
on
that
on
the
data
right
all
right.
Let's,
let's
pack
this
measure,
I
think
I'm
probably
getting
tired
here.
So,
let's
pack
this
message:
if
we
can
pack
a
message,
then
oh.
A
B
A
A
B
B
A
A
So
we're
gonna
try
to
we're
gonna
we're
gonna,
we're
gonna,
we're
gonna
double
check
that
these
things
work
together,
so
secrets,
resolver,
alice,
so
secrets
was
oliver
alice
had
one
too
many
had
one
too
many
statically
defined
keys
and
I've
been
in
too
many
times.
Have
I
gotten
into
a
situation
where
you
start
using
some
library
and
then
all
of
a
sudden,
you
need
to
generate
keys,
and
it's,
like
god,
help
you
you're
deep
in
the
open,
ssl
apis.
A
A
B
A
B
A
B
A
B
A
A
This
is
a
media
or
this
is
the
type
yeah.
Oh,
my
god,
how
many
times
have
we
all
written?
Something
like
this?
The
structure
of
the
body
is
predicted
a
value
of
message.
However,
some
attributes
are
common
in
different.
Many
different
messaging
types.
Metadata
about
a
message
means
the
same
thing,
regardless
of
the
context
and
when
it
is
susceptible
to
red
to
generic
rather
than
message
specific
handling,
the
metadata
can
be
placed
in
headers,
headers
are
siblings
of
body
and
may
be
added
to
any
message
type.
A
B
B
A
B
A
Actually,
I
think
that
shim
code
yeah
that
shim
code
is
kind
of
there's
some
stuff
in
there
that
might
get
reused
and
most
of
it
was
its
own
plugin
system.
Everything
ends
up
being
a
plugin
system,
so
now
we're
just
we'll
just
ditch
that
we'll
just
do
it
with
ndfml.
That's
why
dfml
has
to
be
dependency
free,
it's
just
it'd,
be
nice.
It
would
be
a
one
line
file.
A
A
A
B
A
A
Ids
keys
used
by
specifically
both
senders
or
your
keys,
derived
by
key
agreement.
Okay,
so
they're
going
to
agree
to
you
some
specific
type
of
keys
that
they're
using
both
of
the
same
type
of
asymmetric
key
as
my
understanding
here.
Okay,
I'm
just
it's,
that's
quite
a
scam,
but
that's
my
guess.
Protecting
the
sender
identities.
A
A
This
is
why
I
think
you
need
to
really
pull
this
stuff
out
all
the
way
to
where
you
can
say.
You
know,
have
this
transparency
and
say:
hey,
you
know,
where's
all
the
places
I'm
using
random,
crypto
algorithms!
Okay!
Well,
hey!
You
know,
let's
have
visibility
on
that,
because
that
is
not
easy
to
trace
through
right
how
each
one
is
configured.
So
if
you
can
use
a
data
flow,
you
could
trace
that
through
or
you
know,
if
you
can
represent
it
as
a
graph
and
a
properly
instrument.