Here is a sketch (massively simplifying for reasons of
Setting the scence. You can think of logic as a tool, an API in computing parlance,
to reason about things, where reasoning means deriving true
statements from true assumptions. The things that we reason about
using logic is called a model. What makes logic useful is that
this API, in particular its dominant strain called first-order
logic (of course there are other logics), is completely generic,
meaning we can use it to reason
about teddy bears, cars, bridges over rivers, stars, computation,
whatever you want. Because logic is so generic, we can build up a
generic reasoning infrastructure that can be reused in many
domains. Example include interactive theorem provers, SAT
solvers, textbooks, social conventions such as learned journals,
career structures in the sciences, conventions about when we deem to have
lost/won an argument etc. So logic is a great labour saving
device, because we don't have to reinvent these core tools again
and again for everything that we want to reason about.
Is logic all we need to reason? Naturally not. Because logic is generic, we have to inject domain
specific assumptions, usually called axioms, to cater for domain specific
knowledge (e.g. ZFC or Peano arithmetic to found mathematics,
deontic axioms for reasoning about ethics etc).
What has all of this to do with Kripke semantics?
Often we want to reason about things that change over
time (e.g. traffic at a traffic light, concurrent processes using
shared memory communication, knowledge of observers). We can do
this by injecting suitable axioms into first-order logic for each
domain separately. However, just as with first-order logic, it
turns out that a lot of the axioms that we need to reason about
change are similar regardless of what changes over time. So why
not 'factor out' this similarity and create an API for reasoning
about change, just as we did with first-order logic as an API for
general reasoning? Let this new logic/API be called modal logic.
Now we come back to the notion of model, because models are what
we reason about.
What is this API called modal logic about? Well, things that change.
Let's call them worlds. Now ,
the worlds change into each other over time. Would a description of
this change not be a
binary relation on the set of world? The set of worlds together with the
relation is the model.
Voila, Kripke semantics.
Warning: the description above is simplistic, and terminology is
not uniform. Moreover, for most modal logics the model must also
account for variables.
In more neutral terminology (and still simplifying), a model is a
triple $( W, R, \sigma )$ where
$W$ is a non-empty set
(elements of W are called nodes or worlds or points).
$R$ is a binary relation on $W$, and is known as the
accessibility relation which regulates how 'time' flows.
$\sigma$ is a map from variables (in the ambient logic) to the
powerset of W. The idea behind $\sigma$ is that $\sigma$
controls at what points/worlds the variables are true.
If you want to know even more, maybe check the Wikipedia entries
on Kripe semantics or modal logic or any good book on
the subject such as Modal Logic, by Blackburn, de Rijke and Venema.