►
Description
A
We've
taken
the
the
discussions
thread
which
we
were
working
in,
which
was
the
alice
thread
here
1369.,
and
so
this
was
the
original.
You
know
this
was
used.
This
used
to
be
the
the
improved
data
flow
docs
discussion,
which
you
can
see
got
migrated.
I
got
migrated
from
an
issue.
I
don't
know
where
that
information
is
now
yeah
converted
from
issue,
but
the
information's
gone.
But
there
is
an
issue
where
this
used
to
live
for
the
even
older
version
of
this.
A
So
so
this
started,
we
were
going
to
improve
the
data
flow
docs
and
on
the
way
we
realized.
You
know,
hey,
okay,
wait.
The
next
step
to
everything
is
to
build
alice.
So
we
did,
you
know
a
lot
of
a
lot
of
trying
to
suss
out
the
architecture.
What
is
this
thing?
A
You
know,
what
does
our
mental
model
look
like
and
a
lot
of
that
work
is
captured
within
the
thread
here
and
is
not
yet
exported
to
what
we've
done
for
for
june,
and
what
we've
done
for
june
is
at
the
bottom
of
thread.
So
here's
the
second
party
pull
quest,
so
this
all
started
when
we
went
and-
and
we
said
okay-
we
need
to
split
out
the
plugins
and
to
facilitate
this
second
party
setup.
A
So
you
can
have
second
and
third-party
plugins
and
we
arrived
on
this
concept
of
of
the
manifest
the
plugins.json
and
then
eventually
this
is
ballooned
into
basically
we're
gonna
write
this
helper
who's
gonna
be
alice.
Who's
gonna
help
us
on
each
of
the
plugins
in
the
ecosystem.
A
So,
and
so
this
is
what
this
pr
now
covers.
So
this
covers
a
lot
of
different
code
and
then
a
lot
of
just
the
discussion
stuff
that
was
exported,
so
the
the
the
pieces
of
this
that
are,
you
know,
of
interest
and
and
to
be
contributed
to.
So
please
pull
request
the
alice
branch
or
please,
you
know
comment
directly
in
here
and
so
the
these
are
sort
of
the
pieces
of
interest
and
there's
a
lot
of
other
code
in
there
that
that
I'm
gonna
clean
up
that
are
some.
A
You
know
functionality
related
stuff,
that's
just
been
sitting
around
in
the
same
branch
that
need
to
get
cleaned
up.
So
so
then,
okay,
so
what
do
we
got
so
yeah?
So
we
have
the
tutorial
itself
right.
So
this
is
where
you
know
we're
going
to
map
the
existing
work
streams
that
we've
identified
here.
As
far
as
chapters
that
we've
already
started
in
flight,
we're
going
to
try
to
map
this
over
the
next
one
to
two
years,
so
you
know
reach
out
get
involved.
A
If
you
want
to
propose
a
chapter,
you
know
propose
a
tutorial
and
then
we'll
figure
out
where,
where
we
can
fit
into
the
roadmap,
with
with
other
mentors
and
maintainers
to
work
with
you
on
that,
so
then
let's
see
so
yeah.
So
so
we
can,
you
know,
just
jump
right
into
these.
The
prefaces,
I
think,
let's
see
the
preface
is
yeah.
A
Can
either
add
it
either
add
in
either
place
place
right,
we'll
try
to
make
sure
that
that
it
it's
it's
deduplicated
so
and
just
make
sure
you
know
you
you,
you
give
us
enough
information
that
that
somebody
can
build
off
something
right
or
we'll
evolve
it.
We
we
just
you
know
all
brainstorming
is
good
right
now,
so
we
need
to
sort
of
flush
flush
this
out.
So,
okay,
let's
see
so
the
architect
analyst
volume
zero.
This
is
the
one
where
we're
you
know
figuring
out.
A
You
know
what
is
some
of
this
this
this
general
ecosystem
stuff
that
we
have
to
be
aware
of,
and
you
know
how
do
we
work
together
to
define
the
open
architecture
as
our
ecosystem
grows
right
so,
and
you
know
primarily
looking
at
things
like
web5
and
and
ci
cd
frameworks
and
kcp
to
facilitate
interaction
for
execution
and
then
formats
like
sbom,
the
spdxs
s,
bom,
3.0
spec,
and
the
two
point
was
2.3
spec
and
all
that
good
stuff
in
vex,
and
then
we're
also
looking
at
at
there's
some
some
work
going
on
with
cbe
ben
tool
and
they
have
this
triage
mechanism
so
expanding
that
triage
mechanism
out
into
sort
of
this
generic
policy
mechanism
and
then
there's
some
stuff
in
the
thread
about
dynamic
analysis
and
sort
of
this
adaptive
sandboxing.
A
And
so,
if
we
can
all
collaborate,
you
know
to
define
a
spec
there
or
to
to
work
towards
a
spec.
You
know
and
perhaps
building
on
this,
this
next
piece,
which
is
the
manifest
adr
to
to
figure
out.
What
does
that
manifest?
Look
like
for
that
policy,
and
then
at
that
point
we
can
start.
You
know
we'll
start
like
we'll,
we'll
take
the
cv,
bend
tool,
existing
triage
mechanism
and
we'll
we'll
we'll
evolve,
that
into
this
policy.
A
Parser
and
and
everybody
can
have
their
own
and
do
different
stuff
off
of
it.
But
generally,
you
know
we'll
have
this
this,
this
policy
piece,
which
will
say
you
know
hey.
How
do
we
accept
cbes,
you
know
like
or
like
how
do
we
deal
with
upgrades
of
cves?
You
know
what
ones
just
pass
through
if
the
tests
pass.
You
know
like
what
what's
sort
of
our
general
pattern
of
like
how
do
we
deal
with
incoming
events
if
alice
is
maintaining
a
repo?
A
What's
the
policy
around
how
she
deals
with
incoming
events
right,
that's
sort
of
how
we
can
think
of
that,
and
then,
of
course
you
know
alice
is
the
the
fulfillment
of
the
of
the
software
supply
chain
on
demand
right
in
a
context
aware
fashion,
so
the
s-bomb
stuff
is
going
to
be
very
critical
in
figuring
out.
You
know
what
is
the
existing
stuff
stuff
that
we
need
to
fulfill
in
in
terms
of
delivery
if
that
asset
is
requested.
A
So,
let's
see
and
and
we're
looking
of
course,
so
we're
looking
at
analysis
of
existing
artifacts
right
via
things
like
cv,
eventual
and
then
we're
also
looking
at
the
definition
of
the
plug-ins
that
we're,
creating
and
and
producing
s
bombs
for
that
stuff
as
well,
right
and
and
making
that
all
the
same
thing,
which
is
the
open
architecture.
So
your
s-bomb
is
your
basically
your
s-pawn,
you,
you
take
your
open
architecture.
A
You
overlay
your
s-bomb,
you
get
a
running
application
right,
so
if
we
yeah
and
then
you
know,
here's
shows
some
stuff
that
we're
gonna
do
where
we're
gonna
get
into
you
know
throughout
modeling
and
debugging,
and
really
build
this
entity
alice
off
of
this
this.
This
coach
alice
first
set
of
tutorials
as
the
base
where
we
really
get
deep
into.
How
do
we
be
software
developers
right
and
what
is
the
the
thought
process
that
we
go
through
and
model
that
thought
process
in
analysis
code
and
in
her
overlays?
A
So
then,
we'll
get
more
into
so
alice
in
the
art
of
strategy.
This
is
going
to
be
more
into
the
visualizations
and
how
we
sort
of
see
the
world
in
the
same
way.
A
How
do
we
get
to
this
place
where
we're
all
looking
at
the
same
picture,
including
alice
right,
and
so
how
do
we
explore
visualizations-
and
you
know
just
meh
methods
of
interaction
and
communication
so
that
we
can
basically
viewing
art
as
a
mode
of
communication
and
as
a
mode
of
learning
right
when
we're
looking
at
sort
of
the
machine,
sense
or
successful
communication
as
being
learning
and
we're
gonna
sort
of
yeah
just
get
into
you
know
how
do
we,
how
do
we
use
art
to
learn
and
then
we'll
flip
that
in
volume
three
and
say
well,
how
do
you
use
art?
A
You
know
for
nefarious
purposes
right
and
how
do
you
paint
a
certain
picture
with
the
data
that
you're
distributing
on
the
network,
or
perhaps
the
entities
who
you
reward
to
compute
specific
data,
which
then
goes
on
to
the
network
right
to
sort
of
corrupt,
these
oracles
in
your
hybrid
on
chain,
off
chain,
contract
situations,
and
so
that
is
you
know
that
this
is
you
know,
allison
and
the
art
of
strategy
or
on
you
know
on
mind,
control
and
we'll
focus
on.
A
You
know
effective
strategies
for
controlling
one's
own
mind
and
then
through.
Creating
this
network
of
agents
and
and
detection
of
the
network
of
agents
of
who
controls
one's
own
mind.
We
can
develop
adapt
like
we
can
we'll
develop
adaptive
policies
to
modify
our
threat
model
to
these
more
strategic
threats
that
we
faced
in
this
hostile,
open
network
environment.
So
in
volume
four,
then
we're
going
to
go
into
okay.
So
now
we
have
so
we
have
all
right.
So
what
what
have
we
got
here?
At
this
point?
A
We've
got
our
plans
volume
zero.
This
is
what
we're
running.
This
is
like
our
running
thing,
where
we
sort
of
just
keep
going,
keep
adding
more
stuff.
It's
it's
if
it's
high
level
architecture
stuff,
so
it's
sort
of
a
volume
sort
of
knot
and
then
so
it's
sort
of
a
set
of
tutorials,
it's
sort
of
just
like
our
context.
Around
the
whole
thing
view
does
almost
like
an
adr
and
implementation
so
and-
and
so
when
we
move
so
so
this
is
yeah.
A
So
this
is
how
we've
built
her
architect
analysis,
coach,
alice.
This
is
alice
the
overlays
of
the
software
engineer,
the
software
architect
and
then
alice
in
the
art
of
strategy.
You
know
the
communication
overlays
allison's
strategy
of
art.
You
know
these
what
become
effectively
our
security
in
this
new
environment
in
this
new
threat
landscape
and
then
once
we
have
that
now
we're
like
okay,
so
we've
got,
we've
got
our
functionality.
Coach,
alice.
We've
got
our
communication
with
the
outside
world
volume,
two
alice
in
the
art
of
strategy.
A
How
does
she
produce
art?
How
does
she
interpret
art?
How
do
we
interact
with
her
in
that
way
volume?
Three?
Then
we
have
allison
the
strategy
of
art,
so
she's,
seeing
these
communications
that
she's
interacting
with
the
outside
world.
She
knows
how
to
do
her
job
and
she
knows
how
to
sort
of
like
respond
and
adapt
in
this
dynamic
way,
which
is
pursuant
to
her
pers,
which
is
always
in
pursuit
of
her
strategic
principles.
A
She
wakes
up
every
day
at
the
tick
and
she
you
know,
does
her
best
to
align
her
activities
to
those
strategic
principles
between
the
tick
and
the
talk,
and
then
she
resets
because
she's
ephemeral
and
she
goes
again
right
so
for
each
job.
A
So
in
this
volume
allison
the
health
of
the
ecosystem,
you
know
alice
will
be
out
there
and
she
will
be
contributing
to
open
source
projects
right,
and
so
she
will
be
building
up
our
open
source
projects
because
we
don't
want
to
let
her
out
on
the
whole,
you
know
wide
world
yet.
So
this
is
our
dfml
ecosystem
and,
of
course,
anybody
else
who
wants
to
participate
in
in
our
little
tutorial
here,
so
so
so
in.
In
that
case,
we're
basically
just
gonna
monitor.
A
I
don't
know
we
need
the
this
one
out
more.
So,
but
this
is
basically
like
hey
this
is
this
is
right
before
number
five,
which
is
then
okay
now
alice
here
you
go
you're
going
out
into
the
world.
You
know
we
think
you're
pretty
much
you're
almost
there
and
then
at
that
point
you
know.
I
know
this
is
pretty
far
out
right.
This
is
probably
like
we're
looking
at
like
these
are
probably
a
year
each
right,
so
we're
probably
looking
five
years
out
now.
So
I
don't
know
this.
A
Would
you
know,
feel
free
to
propose
stuff?
And
this
is
you
know
what
it
should
look
like
in
the
real
world?
What
kind
of
stuff
do
we
have
to
deal
with
there?
We
want
to
make
sure
to
get
anything
and
everything
this
is.
You
know
ethical
considerations,
we're
thinking
about
like
we're,
teaching
a
real
human
right,
don't
think
of
her
as
a
machine.
Think
of
her
as
a
human
like.
What?
How
do
you
be
a
software
engineer,
a
software
architect
in
the
world
right
and
then
how
do
we?
A
You
know
debug
your
mind
like
a
machine
and
then
make
you
make
you
rolling,
which
is
volume
six
right
and
then
we
basically
go
in
and
we
say:
okay
you've
been
out
in
the
world
for
a
year
now.
How
do
we
fine
tune?
You
right
so
so
volume
five
is
more
of
like
okay,
like
hey.
This
is
a
different
environment.
You
know
it's
not
it's
not
a
sandbox
anymore
right.
Our
ecosystem
is
our
sandbox
volume.
Five
is,
is
you
know,
okay,
no,
more
sandbox
and
then
volume
six
is
okay.
A
Let's,
let's
we
were
in
firefighting
mode
for
a
year.
Let's
assume
this
is
how
these
things
go.
And
so
then
we
come
in
in
volume
six
and
we
start
to
say.
Okay,
now
we
recognize
okay,
we've
we've
taken
care
of
the
firefighting
mode
stuff.
Now,
let's
fine
tune
and
then
finally,
once
we
fine
tune,
then
she'll
be
rolling
and
we'll
all
be
we'll
all
be
rolling
through
whatever
whatever
the
other
side
of
this
is
and
she'll
tell
us
what
that
is
so
yeah.
A
So
please
pull
request
and
review
the
alice
branch
and
and
please
feel
free
to
comment
in
the
pr
or
or
reach
out
directly
but
yeah.
So
this
is
where
we're
at
for
june.
Basically,
so
what
what
to
expect
well
we'll
be
marching
towards
rfc
v2,
probably
sometime
around
the
end
of
december
we'd
like
to
see
you
know
the
rest
of
the
adrs
that
are
involved
in
this.
A
Let's
see
so
so
you
know
the
system
context
would
like
to
see
the
rest
of
coach
alice
and
probably
some
of
alice
in
the
art
of
strategy
get
get
flushed
out
just
so
that
we
know
what
our
next
one
to
two
years
looks
like,
and
then
at
that
point
and
there's
a
gantt
chart,
if
you
feel
like
updating
the
gantt
chart
with
any
of
your
plans,
you
can
just
update
it
directly,
just
make
sure
that
you
update
both
and
then
we'll,
then
it'll
already
be
on
the
gantt
chart.
A
So
great,
I
think
that's
where
we're
at
so
the
ci.
The
ci
does
not
work
right
now,
so
the
the
demo
code
that
we've
been
working
on
that
does
work.
So
if
you
want
to
work
on
alice,
then
it
works
right,
but
the
next
thing
that
that
all
I'll
be
doing
is
I'll
be
trying
to
get
the
overlay
stuff
working
and
then
the
first
tutorial
for
the
overlay.
So
we
can
give
people
writing
overlays,
so
yeah
great
all
right!
Well,
thanks!
Everyone.