►
From YouTube: GitOps Working Group Meeting 20210910
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
All
right
book
shares
meeting
kicking
off
we're
going
to
be
working
on
the
principles
today.
I'm
hoping
we
can
finish
these
up
today,
because
we're
so
close
so
so
close
is
there
anything
else
that
we
need
to
discuss.
B
We
just
have
the
only
the
only
items
well,
just
some
of
the
details
for
three
and
four
or
sorry,
four
and
five.
Okay,
all
right.
Actually,
there
is
one
more
detail
for
three
that
I
I
realized
that
we
didn't
we've
discussed
as
a
group,
and
I
think
there's
no
one
in
the
group
that
has
debated
this
at
all,
which
is
that
the
language
that
we
had
remember.
We
were
talking
about
delivery
of
the
desired
state
declarations
from
the
repository
through
runtime,
environment,
etc.
B
I
just
think
we
should
change
the.
I
don't
want
to
spend
a
lot
of
time
on
that
right
now,
but
I
could
just
like
draft
like
a
little
sentence
about
this,
essentially
saying
that
that
those
are
that
those
are
synced
and
use
the
pull
method,
as
as
the
primary
example
of
that
and
just
sort
of
say
that,
simply
because
everybody
in
every
single
meeting
we've
we've
had
has
agreed
that
that's
the
way
all
of
our
tools
and
all
of
the
git
ops
tools
do
that.
B
Do
this
very
very,
unlike
you
know,
the
ci
web
hook
style
where
you're
just
like
kind
of
like
sending
all
these
configurations
and
packages
over.
You
know
it's
always
being
red.
Yeah.
A
Paul
paul
versus
push
is
important
to
me.
One
thing
that
I've
gives
me
a
little
bit
of
pause
is.
A
If
I
have
like
let's
say
I
have
a
greatest
cluster
sitting
on
a
private
virtual
private
network
within
amazon,
and
I
have
four
clusters
there,
there's
there's
a
configuration
with
argo,
where
basically,
I
can
set
up
my
argo
server
instance
on
one
cluster
and
then
I
can
add
several
other
clusters
to
the
management
of
that
cluster.
A
The
motion
is
still
pulled
to
that
cluster,
which
then
pushes
to
the
other
clusters.
So
I
wonder
if
this
would
be
violating
the
principle,
because
you're
using
essentially
an
intermediary
to
pull
that
is
sort
of
like
a.
You
could
argue
that
it's
sort
of
like
a
traditional
ci
kind
of
approach,
in
the
sense
that
this
thing,
because.
C
B
I
was
going
to
say,
I
don't
think
it
yeah.
I
don't
think
it
that's
one
of
the
reasons
why
I
was
suggesting
that
we
we're
sorry
that
I
was
going
to
say
we
should
word
it
as
a
sink
and
describe
full
as
the
example.
D
C
B
To
sort
of
you
know
because
we
do
want
this
is
the
primary
use
case,
but
there
are
cases
like
what
you're
saying
like
what
argo's
doing
with
other
clusters
and
what
cappy
does
yeah.
A
But
yeah,
and-
and
your
your
point,
leonardo
leo
is
really
good
is
which
is
like
there
are
some
services
out
there
that
basically
would
allow
you
to
or
like
like
as
part
of
your
declaration.
It
will
include
like
aws
resources,
and
it's
like
okay,
like
at
one
point,
do
we
view
that
as
a
pull
method,
because
it's
like
has
to
mess
with
the
aws
api
to
do
that
and
like
technically,
it
wouldn't
even
have
to
be
in
aws.
In
order
to
achieve
that,
you
know
what
I
mean
so
like
I
agree.
A
That
poll
is
actually
super
important
pulling
from
the
cluster
rather
than
like
just
triggers,
because
otherwise
you
you
lose
continuous
reconciliation,
but
I'm
just
yeah,
I
think,
pulling
as
an
example
is
good.
I
just
wonder
if
we
I
don't
want
to
accidentally
cut
out
like
all
these
use
cases
where
I
think
they
do
fit
under
githubs.
C
B
Sorry
deployed
automatically,
basically
something
like
this.
Just
it's
really
not
a
big
change,
it's
just
it's
something
that
we
didn't
really
get
to
in
the
discussions
with
the
whole
group,
because
again
we
kept
getting
stuck
like
somewhere
down
down
the
line
but
yeah
like,
but
it
was
a
point
that
was
raised
many
times
just
so
one
sec.
Maybe
something
like.
Let
me
just
type
out
what
you
were
saying
for.
B
A
B
B
B
Method
is
or
if
we
should
just
leave
that
for
for
for
the
supporting
documents.
C
B
Yeah
I
mean,
for
example,
if
this
were
called
subversion.
Ops-
and
this
were
this-
was
a
model
back.
You
know
when,
like
before,
git
won
the
vcs
wars,
we
probably
have
renamed
it
by
now,
we'll
just
rename
the
whole
thing
state.
A
B
Yeah
yeah,
I
mean
seriously
version
control.
Ops
could
have
been
a
a
thing,
but
it's
not
it's
not
catchy
like
get
opposite,
not.
B
A
B
Okay,
so
never
mind
about
the,
for
instance.
Get
you
know
we
can
always
revisit
that
if
the
if
the
maintainers
want.
A
To
change
that
it's
actually,
the
problem
I
was
having
with
three
here
is
between
the
repository
and
the
runtime.
I
was
like
oh
repository,
should
we
say
repository?
Is
there
another
more
like
inclusive
term.
E
Oh,
oh
sorry,
the
the
desired.
B
A
B
A
Well,
like
with
with
version
and
immutable
what
was
interesting
one
of
the
interesting
things
about
this
is
that
it
could
be
a
google
sheet,
because
it's
versioned
and
it's
immutable.
B
Before
I
think
there
was
some
language
around
state
store,
but
that
was
shot
down,
because
that
has
the
connotations
there
are
that
people
are
almost
always
thinking
about.
I
mean
it
seems
fine
to
me
one
way
or
the
other.
C
C
B
Well,
I
I
think
it.
I
don't
think
that
sounds.
That
sounds
okay,
but
I
think
it's
it
reads
weird,
because,
because
I
think
what
we
want
to
do
is
like
we
want
to
make
clear
when
folks
read
this
they're
still
learning
this
stuff
right
and
even
people
in
the
get
ops
working
group
were
often
describing
the
desired
state
as
the
repository
itself,
but
that
doesn't
really
totally
make
sense
linguistically
because
or
you
know
what
I
mean
like
in
descriptions,
because
we're
actually
we're
actually
moving
it.
The
desired
state
is
the
it
is.
C
But
the
desired
state
could
be
stored
in
multiple
repositories
could
be
spread
around
like
the
desired
state
of
my
full
system
might
be
my
infrared
repository
operations,
repository
that
points
to
the
repositories
of
all
my
application
teams
that
have
their
own
desired
state.
So
it's
really
not
one
repository
that
represents
the
full
system
that
describes
the
whole
system.
B
B
Maybe
we
should
just
propose
using
that
consistently
because
it
was
already
used
before
and
and
what
we'll
say
is
the
desired
state
repository
is
what
we're
meet,
what
we
mean
when
we're
talking
about
the
storage
space
or
spaces
for
the
desired
state,
whether
that's
like
the
the
cloud
hosted
database
that
powers,
google
cheats
or
whether
that's
you
know,
like
a
hosted
git
instance
like
github,
you
know
or
whether
that's
you
know
some
immutable
database
system
like
the
one
I'm
forgetting
right
now,
but
you
know.
A
B
It
I'm
concerned
about
that
this
will
be
confused,
but
confused
with
reconciliation
itself
that
we
want
to
like
like
make
it
really
really
clear
that
what
we're
deploying
are
the
the
manifests
for
not
deploying,
but
what
we're
thinking
are
the
actual
instructions,
not
not
not
somehow
trying
to
sync
the
desired
state
in
the
actual
state.
B
Yeah,
you
know
what
I
mean.
It
is
because,
like
otherwise
like
that's
really
a
step
before
the
reconciliation
step
where,
where
you
are,
you
know
ultimately.
B
You
see
what
I
mean
like
it
like.
I
think,
maybe
that's
why
the
language
before
was
sinking
from
the
repository
to
runtime
environment,
because
it's
just
easier
to
say
and
make
clear
that
you're
talking
about
like
you
know
how
about.
B
Yeah
my
concern
is
this:
here's
the
main
thing
is
that,
like
just
the
ambiguity
so
like
the
desired
state,
declarations
are
both
in
the
source
of
truth.
The
repository
that's
the
source
of
truth,
essentially
like
yeah
right,
where
you're
interacting
with
get
and
those
those
very
same
desired.
State
declarations
are
all
also
have
to
be
accessible
inside
the
runtime
environment.
B
You
know
essentially
yeah
synced,
you
know
so
that
it
can
perform
its
operations.
C
B
That
that's
true,
that's
that's.
I
think,
that's
why
this
step
was
here
in
the
first
place,
because
that's
why
we
were
talking
about
software
agents
in
the
first
place
again,
what
you're
saying
dan
about
the
runtime
environment
doesn't
have
to
be
its
own
runtime
environment.
It
can
simply
be
that
you
know
your
you
so
yeah,
ultimately,
that
there
is
a
that
there
is
a
runtime
environment.
That's
pulling
this
like
model
model
is,
is
basically
it's
like
you,
you've
got
your
you've
got
your
initially
we're
talking
about
kubernetes.
B
Let's
just
say
anything:
you've
got
your
your
your
declarative
configuration
for
all
of
your
infrastructure,
all
your
apps
and
everything
inside
of
git
right
and
then
you've
got
a
runtime
environment.
Where
agents
are
there
and
they're
getting
that
information
and
then
they're
like
alright
cool
now,
I'm
going
to
just
make
sure
automatically
to
do
the
best
that
I
can
to
make
to
to
to
do
your
bidding
based
on
your
instructions
and
you're.
B
Only
talking
again
I
mean
that's
basically
what
a
and
you
know
we
notified
you
when
there's
a
divergence,
whatever
else
right,
but
that's
basically
what
github
says.
Oh
you
know.
I
think
the
point
about
a
closed
loop
is
also
important
too,
so
maybe
it
does
it
intelligently.
C
B
B
I
don't
think
at
least
no
so
far,
no
one
has
described
the
the
management
cluster
concept.
That
dan
was
describing
with
argo
and
fluxes,
as
well
as
breaking
the
principles.
C
But
my
my
my
point
of
view
is
that
the
one
thing
that
we
want
to
communicate
the
principle
three
right,
because
I
think
we
have
to
remain
within
the
constraints
of
what
we
want
to
communicate
with
that.
One
principle
at
this
point
right
is
that
there
is
no
human
interaction,
but
there
is
no
human
action
involved
in
the
continuous
reconciliation
process
that
is
discussed
in
principle,
four,
so
the
real
value
that
we
want
to
communicate
this.
C
It's
automated
it's
non-human,
that's
the
one
component.
That's
the
one
argument
that
principle
three
is
making.
So
that's
the
reason.
I'm
counting
compliance
is
to
agree
with
that
last
statement,
it's
not
about
where
it's
stored,
where
it
stored
this
principle
too.
It's
not
about
what
does
the
reconciliation
and
when
it
happens,
which
is
principle
four,
it's
not
about
the
closed
loop
either
because
that's
principle,
five,
the
one
thing
is
that
the
only
way
to
like
the
it's
fully
automated
period.
That's
the
one
thing
that
principles.
B
You're
right
like
if
we're
getting
down
to
an
essential
description,
that's
correct
and
we
could
have
actually
even
kept
the
first
sentence
because
that's
it's,
we
don't
really
see
how
it's
deployed.
B
You
know
you
know
we
could
just
simply
say.
B
Or
something
like
that,
you
know
it
may
not
really
be
as
quite
as
clean,
but
you
know
we
could
also
just
not
say
it
at
all
and
make
sure
and
just
make
sure
to
highlight
that
in
the
supporting
documents
and
we're
gonna
have
a
lot
of
best
practices
that
we
want
to
highlight.
B
B
B
Yeah
and
delivery
right,
I
guess
I
was
just
thinking
sinking-
would
help
but
yeah
and
then
repository
right.
So
what
if
we
okay?
So
what
if
we,
you
were
saying,
here's
a
suggest:
here's
a
suggestion.
What,
if
we,
what
if
we
changed.
A
A
We
could
just
say
in
a
glossary,
because
repository
doesn't
eliminate
using
like
a
like,
like
if
you,
if
you
had
these
stored.
A
But
they're
not
there's
a
it's
a
little
fuzzy
like
charlie
museum
like
chart
museum,
it
would
be
a
repository,
so
that's
very
straightforward.
Does
it
keep
it
out,
but
a
repository
has
a
connotation
that
I
think
would
exclude
like
google
sheets.
We
don't
I
don't
again.
I
don't
care
about
google
sheets,
it's
just
it's
just
keeping
it
as
universal
as
possible,
because
it's
like
well
as
long
as
it's
the
requirement
is
version
immutable,
not
a
repository
right.
Okay,
so
removing
that
proposed
change
just
going
back
to
what.
C
A
A
D
B
We're
kind
of
getting
closer
because
yeah
I
mean
anyway,
this
is
cleaner,
it's
better!
Yes,
we
did
it
a
little
a
little
clearer
and
the
clarity
here
we
can
use
as
we
get
farther
along.
I
think
that's
why
my
hypothesis
about
why
we
had
difficulty
in
the
group
is
that
these
is
that
these
principles
are
are
progressive.
B
You,
you,
each
principle
uses
the
concepts
of
the
previous
principles
or
the
language
of
the
previous
centrals,
and
that
the
the,
if
there's
even
slight
ambiguity
in
the
early
ones,
by
the
time
you
get
to
the
later
principles
you
could,
it
just
seems
to
load
with
wait.
I
do
have
one
more
thing
on
principle.
Sorry,.
A
A
A
B
B
B
What
I'm
saying
is
this
this
suggestion
before.
B
Where
the
desired
state
always
wins
right
or
the
desired
state,
is
the
sort
or
this
we're
using
language
right
now
to
talk
about
the
source,
and
I'm
just
wondering
like.
Does
that
mean
that
we
need
to.
B
C
B
Yeah
I
mean
that's
like
the
problem
we've
run
into
all
along.
It's
like
we
could
just
make
it
all
one
paragraph,
but
we're
trying
to
split
them
off
into
separate
principles,
so
that,
like
like
just
like,
in
short,
like
the
concept
of
like
like
first
we
just
anyway.
The
version
in
immutable
is
strange
because
we're
using
kind
of
it's
like
two
things,
but
it
really
is
just
these.
Are,
I
think
principle
two
is
these:
are
the
requirements
for
how
your
your
declarations
are
stored.
B
B
A
B
C
B
B
Put
one
at
the
top,
we
know
we
wanted
to
be
like
we
wanted
to
mention
this
you're
in
the
wrong
principle.
Right.
B
All
right,
so,
oh
man,
I'm
like
reminding
myself
of
the
skt
xkcd
standards.
Comic,
you
know
the
one
about
like
we've
got
14
different
standards.
We
need
one
standard
of
the
rule
of
all.
You
know.
B
Standards-
let's
put
this
at
the
top,
just
as
like
a
like,
we
know
we
want
the
source
of
truth
right.
We
want
to.
We
want
to
point
to.
B
We
want
to
point
to
this,
the
desired
state
store.
You
know.
C
B
B
Well,
it's
continuously.
Well,
I
think
that
the
watch
from
within
part,
I
think,
is
it
goes
into
the
closed
loop
concept.
I
think
maybe
that
fits
better
with
a
closed
loop,
because
it's
really
talking
about
a
feedback
loop
from
the
output
of
the
system
itself.
C
You
know
so
the
thing,
though
I
think
what
we
had
a
lot
of
discussion
about
for
principle.
4
is
whether
it
actually
whether
we
could
say
that
reconciliation
is
a
is
a
required
given
fact
that
occurs
continuously
or
whether
just
actions
would
be
taken
to
attempt
continuously
to
continue
to
reconcile
what
wasn't
that
kind
of
like
one
of
the
items
that
produced
multiple
versions,
yeah.
C
B
Well,
so
here's
what's
interesting
here
is
that
in
the
old
version
4
it
really
just
said
software
agents
and
that
really
that's
just
describing
the
fact
that
there
are
that
there
are
agents
that
are
running
in
the
runtime
environment.
B
You
know
period
and-
and
so
I
think
like-
where
did
what?
Where
did
we
go
from
here?
Like?
Oh
sorry,
one
sec.
B
B
Really
like,
I
think
this
was
in
some
ways.
It
was
like
much
simpler
because
it
was
saying
you
know
like
in
the
next
principle
like
we
have
to
make
sure
that
they're
syncing
between
the
you
know
the
desired
state,
storage
and
the
runtime
environment
right,
so
that
in
the
in
the
following
principle,
the
software
agents
can
then
access
that
configuration
or
reconcilers
can
access
that
configuration.
B
You
know
and
reconciles
are
running
in
the
runtime
environment
and
I
think,
like
the
reason
that
closed
loop
was
separated,
as
the
fifth
principle
was
just
because,
because
it
really
emphasized
the
the
closed-loop
concept
and
what
we,
what
we
tried
to
do
earlier
with
the
genomes
working
group,
was
to
merge
or
the
principal's
committee
that
we
ended
up
calling
a
committee
because
they
were
just
consistent
people
that
showed
up
to
those
discussions
tried
to
merge
several
of
these
together,
and
I
think
we
recognized
now
that
we're
like,
oh
my
god,
how
much
time
has
passed
like
we
can't
wait
years
to
make
us
an
initial
version
of
this
right
so
or
an
approved
version
of
this
by
the
by
the
working
group.
B
So
we're
like.
Look,
let's,
let's
separate
them
back
out
again,
because
they
really
didn't
work
very
well
trying
to
combine
them.
You
know,
so
that's
the
only
place
I'm
at
and
then
what
we're
saying.
So,
what
we're
ultimately
saying
here
in
number
four
is
really
just
that,
like
the
the
actions
that
are
taken
are
coming
from
within
the
system.
Right
is
that
kind
of
what
you
were
saying
before,
like
that.
C
Well,
actually,
I
think,
what's
most
important
about
this
principle,
because
we
already
talked
about
automatic
synchronization
in
principle,
three
right
to
me,
the
most
important
attribute
of
a
system
that
applies
principle
four.
Is
that
it's
continuous
that
it
continues
right?
I
think
that's.
The
most
important
thing
right,
we
already
know
like
there's,
got
to
be
some
form
of
soccer
agent
performing
this
action,
because
principle,
4
is
all
about
automation.
You
cannot
do
something
fully
automated
unless
there
is
a
software
agent
doing
that
there
is
no
way
for
a
human
to
do
something
fully
automated
right.
B
So
how
about
how
about
this?
Since
operating
a
closed
loop,
really
describes
the
how
the
actions,
basically
actions,
are
intelligently,
initiated
right
or
attempted
based
on
feedback
from
the
system?
That's
the
whole
concept
of
closed
loop.
Maybe
we
don't
really
say
what
the
software
agents
do
just
say:
they're
continually
running.
D
C
B
C
But
what,
if
like,
if,
if
we're,
keep
saying
scott,
is
that
the
actual
action
attempts
are
part
of
the
closed
loop,
a
lot
of,
but
then
it
doesn't
reconciliation,
because
the
principle
is
continuing
to
reconcile
not
continuously
compared
and
reconciled
means
that
you're,
actually,
your
end
state
is
one
that
is,
that
is
reconciled.
That
is
synchronized.
That
is
consistent
right.
It's
not
confusing
compared.
B
And
the
point
is
that
the
point
of
what
we
want
to
say
with
the
continually
reconciled?
I
think
it
may
be
now
that
we've
like
discussed
it
more
because
because
we're
saying
that
that's
happening,
but
but
the
closed
loop
point
will
just
make
a
separate
point.
It's
still.
It's
still
a
point
about
how
how
these
are
continuously
reconciled
or
how
they're
how
reconciliation
happens
like
reconciliation
is
continuous
here
and
then
reckons,
and
then
the
system
is
operating
in
closed.
B
Loop
really
just
means
that
we're
is
that
the
system
is
looking
for,
like
it's,
not
just
a
dumb
system.
That's
simply
that
sen
that
like
tries
to
do
the
same
thing
over
and
over,
and
then
you
as
a
human,
have
to
get
in
and
figure
out
what
went
wrong
it
intelligently
does
different
things
based
on
the
feedback
that
it
gets
from
the
actual
system,
right
from
the
from
the
from
the
observed
output.
B
B
C
E
C
C
We
want
to
keep
source
of
truth.
Okay,
something
is
actually
an
initiative
to
reconcile
the
desired
state
period
as
its
source
of
truth.
B
Oh,
I
think
it
should
be
desired.
State
declarations,
because
because
there's
because
in
the
last
principle,
we're
deploying
or
that
we're
making
sure
that
those
declarations
are
are
in
the
runtime
environment,
accessible
to
the
running
agents
already.
But.
C
C
B
C
B
Agree
with
you
any
of
those
could
work
the
only
the
only
reason
that
it
feels
I'm
not
like
trying
to
like
create
a
hill
to
die
on
like
unnecessarily,
but
the
only
reason
that
feels
weird
to
me
is
that,
like
it's
very
easy,
when
someone
just
describes
the
desired
state
for
for
them
to
think
about
the
actual
state
store
itself,
you
know
the
source
of
truth.
State
store
itself,
whereas,
whereas
principle
three
is,
is
making
sure
that
those
declarations
that
are
from
the
source
of
truth
are
are
like
now
in
in
the
hands
of.
C
B
Because
it
was
too
long
and
I
knew
it
and
you're
right.
D
B
B
C
B
A
B
C
B
I
think
ultimate,
ultimately,
that
this
is
that
it's
a
that
it's
really
a
feedback
mechanism,
not
just
a
not
just
an
open
loop
but
a
closed
loop
like
in
control
theory.
I
think
that's,
that's
the
main.
That's
the
main
point
and
like
how
does
that
apply
to
people?
I
think
it.
It
just
means
that
you
can
trust
your
reconcilers
to.
You
should
be
able
to
trust
your
reconcilers
to
do
the
right
thing.
Not
just
be
a
simple,
not
just
be
a
simple
like
apply
script,
you
know
but
yeah.
B
Scary,
as
you
try
to
let's
see,
I
can
think
of
a
couple
of
different
ones,
but
I
don't
want
to
be
too
specific.
I
don't
know
just
to
help
me
understand
it.
You
can
be
specific
yeah
like,
let's
just
say
we're
talking
about
like
helm,
helm,
integration
right
which
all
the
major
get
offs
tools
have
yeah
helm
has
different
life
cycle
hooks
and
different,
and
things
need
to
be
applied
in
a
specific
order.
B
One
way
to
do
it
is
to
just
hand
it
off
to
the
helm,
client,
which
has
some
of
this
logic
built
into
it,
but
not
it's
not
not
really
like
retry,
retries
and
and
and
other
things
like
that
are
really
outside
the
scope
of
the
home,
client
yeah.
So,
for
example,
if
you're
in
a.
C
C
C
B
B
A
Be
okay
guys
we
tries
and
and
everything
else
we've
talked
about
so
far
I
feel
like
is
covered
by.
B
A
Of
we
don't
have
any
restriction
here
on
like
oh,
it
might
apply
multiple
strategies
to
reconcile.
That's
not
something
we
take
an
opinion
on.
It
might
do
that.
It
might
not
do
that.
It
sounds
like
what
you're
really
talking
about
is
that
five,
the
software
agents
should
provide
timely
feedback
like
it
sounds
like
what
you're
really
looking
for
is
a
feedback
mechanism.
Well,
they
should
be
aware.
B
Of
their
own,
like
the
software
agents,
should
be
aware
of,
like
basically
they're,
not
just
like
a
simple,
dumb
rum
that
has
no
idea
of
anything
outside
of
itself.
The
software
agent
should
be
aware
of
of
a
feedback
from
the
system
from
previous
attempts
from
its
own
attempt
and
from
its
own
previous
attempts,
so
like,
for
example,
even
if
we're
talking
about
notifications,
you
want
notifications
to
be
intelligent.
B
A
Let's
say
I
I
changed
my
declaration
to
say
that
I
want
more
nodes
and
the
system
that
I
make
that
declaration
on
can't
provide
more
notes.
So
it's
continuously
looking
insane
it's
supposed
to
have
five
notes.
It
only
has
four
I'm
trying
to
get
five
notes.
I
can't
because
I
the
api,
it's
not
providing
me
another
note.
So
what
does
this
principle
then
mean
it
sends
me
an
alert
or
it
says
hey.
I
can't
do
that
like
or
there's
some
maximum
retry
or
something.
B
Yeah,
I
mean
that's,
that's
the
right
exactly
so
that's
why
the
answer
is
yes,
depending
on
your
agent,
depending
on
how
you
can
sometimes,
depending
on
your
configurations
and
sometimes
depending
on
things
that
might
be
built
into
the
agent
itself,
depending
on
what
tool
you're
using
you
know,
I
mean
I
can
tell
you,
I
I
know
more
about
how
flux
does
it
than
than
how
organized
I
want
to
look
into
it
more
under
the
hood
about
power
is
doing
that
currently
and
other
tools,
but
for
for
most
tools
and
even
with.
B
Yeah
I
mean
with
basically
with
like
kubernetes
control
the
runtime.
You
can
have
different
responses
based
on
certain
events,
because
what
you're
trying
to
do
might
excuse
me
different,
not
events,
I'm
sorry,
it
used
to
be
conditions
now,
based
on
different
conditions
that
are
that
are
their
output
to
your
c
are
basically
their
their
their
output
by
the
system
based
on
things
that
are
happening,
and
then
your
controllers
may
respond
differently
based
on
what
stage
you
are
in
those
conditions
or
or
when
those
conditions
are
met.
B
You
know
I
I
think
I
don't
know
if
I
have
a
really
good
description
right
now
of
why
a
closed
loop
is
important.
Except
for
that
you
know
well,.
A
Like
I'm
thinking
of
when,
if
I
go
to
make
a
change
to
a
just
like
a
pvc
and
there's
pv
protection,
you
know
so
it
doesn't
want
to
it,
can't
recreate
it.
It
needs
to
be
deleted
and
then
recreate.
You
can't
just
apply
it
and
I
still
feel
like
this
is
sort
of
covered
by
four,
even
though
we
don't
say
like
the
agent
should
be
smart
enough
to
do
something
because
smart
enough
to
do
something
basically
means
we
don't
know
how
to
describe
a
principle
that
covers
the
eventualities
so
yeah.
A
C
C
C
Correct,
but
if
you
read
this
independently,
the
desired
state
of
a
get
ups
managed
system
must
be
operated
in
a
closed
loop.
That's
just
one
sentence:
one
very
likely
way
to
interpret
that
is
that
a
system
that
is
managed
by
get
off
there's
gonna
flow
feet.
It's
gonna
think
back
into
the
desired
state,
because
the
desired
state
is
operating.
A
close
look.
A
Is
this
about
like
a
meta
state
like
like,
we
have
our
state,
but
then
we
have
this
sort
of
meta
state,
which
is
like
I've
attempted
to
do
this
thing,
and
I
should
have
a
policy
for
how
to
deal
with.
A
If
I
can't
do
this
thing,
there
should
be
a
policy
that
allows
me
to
make
some
sort
of
concession
or
something
like
I've
declared
a
state
that
has
a
an
image
that
has
a
known
severe
security
vulnerability,
and
I
also
have,
as
sort
of
my
meta
state,
a
policy
that
says
that
can
never
be
deployed,
so
that
would
like
override
the
desired
state.
But
I
don't
know
is
that
what
it's
about
more?
So
that's
a
that's
a
good
example.
B
I
mean,
I
think,
you're
right,
that's
a
good
example
like
any.
Basically,
I'm
like
trying
to,
like
think
of,
like
really
good,
like
obvious
examples,
as
a
way
to
explain
it,
because
I
didn't,
I
didn't
invent
this.
You
know
these
were
these
were
from
like
like
these.
These
have
been
around
for
like
the
last
several
years
and
in
fact
I
just
remembered
that
we
in
our
attempt
to
combine
in
our
earlier
attempt
to
combine
several
of
the
principles
it
just
led
to
a
lot
of
debate
and
one
of
the
big
debates.
B
If
you
remember
from
moshe,
was
again
I
there
are
many
different
issues
that
came
up
and
perhaps
reasons
why
there
were
misunderstandings
or
or
whatever,
but
but
one
of
them
was
that
you
know
now,
I'm
just
thinking
as
much
as
I
can
back
on
one
of
his
issues
about
wanting
to
keep
a
closed
loop
in
the
description
of
principle.
Four
as
it
used
to
be,
you
know
when
they
were
combined.
B
The
group
really
felt
that
it
didn't
belong
there
and
the
one
thing
that
I
don't
think
really
for
some
reason
came
back
came
up
was
oh
well.
Why
don't
we
just
like
have
like
keep
that
as
his
own
principle,
just
like
we
have
in
the
read
me
right
now
of
the
get
off
working
trip.
You
know
yeah
that
that's
the
only
reason
I'm
suggesting
coming
back
to
it.
I
don't
have
any.
I
don't
really
have
any
well.
C
A
B
We,
how
about
this
as
a
question?
Can
we
thanks
for
the
extra
time?
Can
we
send
principals
one
through
four
to
the
maintainers
and
ask
their
feedback
about
the
value,
the
value
of
keeping
a
closed
loop
as
principle
five
because,
like
I
don't
think
we're
like
playing
god
here,
we're
just
trying
to
incorporate
feedback
that
we've
had
so
far
and
get
the
ball
rolling,
so
we
need
their,
we
need
their
feedback.
Can
we
just
hear
what
they
have
to
say?
Everyone
else
in
the
group
hear
what
they
have
said.
I.
A
Am
very
anxious
about
trying
to
give
it
a
partial
review
because
then
like
like,
if
we're
saying
well,
we
can't
articulate
fully
the
value
of
five,
so
we're
going
to
remove
it
and
send
them
here.
The
four
principles
is
there
anything
missing?
That's
one
thing,
but
sending
it
and
saying
we're
still
working
on
the
fifth
principle.
I
feel
like
it's
no.
B
I
I
was
just
saying
that
we,
what
you
said
right,
then,
is
what
we
should
probably
do
is
say
we
we
can't.
We
can't
right
now
with
all
the
feedback
from
the
group,
justifying
why
this
should
remain
as
a
principle
as
a
as
a
as
a
requirement.
You
know,
basically
like
get
ops
agents
can
work
or
base
the
system
can
work
in
a
closed
loop.
Does
it
always
have
to.
That
is
actually
a
good
question.
B
C
I
I
like
dan's
approach
of
saying
you
know
these
are
principles,
one
through
four.
We
think
these
are
basically
covering
all
the
bases
of
the
getup
system.
There
is
get
up
just
principle,
five,
that
we
really
cannot
identify,
whether
there's
anything
missing
that
should
be
incorporated
by
that
principle
and.
A
C
A
I
might
I
might
prefer
actually
just
putting
out
and
saying
what's
critical
about
this
principle,
where
this
is
one
we're
stuck
on
and
we're
working
on,
and
we
can't
articulate
just
cuz
like
I
don't
know
I
feel
like.
I
don't
want
to
make
the
decision
in
haze
to
say
we're
removing
this
thing
either.
You
know
it's
just
yeah.
B
So
so
how
about
how
about
this
yeah?
How
about
we?
Oh-
how
about
we
do
that
and
we
yeah
how
about
we
just
do
that.
We
send
that
we
send
that
email
to
the
maintainers
say.
B
A
B
We
feel
that
one
one
through
four
seem
to
cover
our
bases.
Five
seems
like
an
important
concept,
but
is
it
a
requirement
that
should
be
a
principle
and
if
so,.
C
C
For
monday
afternoon
my
afternoon
after
1pm
costa
rica,
1
pm
central
is
wide
open,
so
we
haven't
seen
that
already.