What Bayesian inference actually does, in pictures

How the system turns your questions into probability distributions — and why that's more useful than a single answer.

Simmis answers a question in three moves: model the domain, simulate scenarios on it, and learn from what happens. This note is the learn step — turning evidence into calibrated belief. Same running decision throughout: should we hire three engineers in Q3 instead of Q4?

Every time you ask Simmis a question, you get back something more than a number. You get a distribution — a range of futures the system considers plausible, weighted by how likely each one is. To understand why, you need to understand Bayesian inference. Not the math. The shape of it.

Start with what you already believe

Before you show the system any data, it already has a belief. Not a guess in the pejorative sense — a structured representation of uncertainty. This is the prior.

A wide, flat prior says: “I don’t know much. Many values are plausible.” A narrow prior says: “I have strong domain knowledge — the answer is probably in this range.” Both are valid. The prior is where you encode what you know before you look at the evidence.

This matters because most decision-support tools skip this step. They assume a blank slate, then fill it with whatever the data says. Bayesian inference does the opposite: it asks you to make your assumptions explicit, then updates them in light of evidence.

Data arrives. Beliefs shift.

Now you show the system some data — observations, measurements, historical outcomes. Each observation is a constraint: it makes some values more plausible and some less. The system computes how likely each value of the unknown was to produce this data. That’s the likelihood.

The likelihood isn’t a belief. It’s a measurement of fit: for each possible value of the unknown, how well does it explain what we observed?

The update

Multiply prior by likelihood, normalize so it sums to one, and you have the posterior — your updated belief after seeing the data.

The posterior is narrower than the prior because data reduces uncertainty. It’s centered on — but not identical to — the data cluster, because the prior pulls it slightly. That pull is the whole point: prior knowledge doesn’t disappear when evidence arrives; it just gets weighted appropriately.

Why a distribution beats a number

Most systems give you a single answer: “Q3 velocity will be 82 story points.” Bayesian inference gives you a distribution: “Q3 velocity will most likely be around 78–86 story points, with a 12% chance of falling below 65 if onboarding runs long.”

That tail — that 12% — is information. Ignoring it means ignoring a real scenario the data supports.

Sequential updating

One more thing. Bayesian inference is sequential. Today’s posterior becomes tomorrow’s prior. Every new observation makes the system sharper.

This is what “gets smarter over time” means concretely. The model isn’t just accumulating data — it’s accumulating evidence about the shape of your world. After eight weeks of sprint data, the system has a much sharper picture of your team’s velocity distribution than it did at week one.

It also means the system can tell you when its beliefs are fragile. A wide posterior isn’t a failure — it’s honest uncertainty. Sometimes the honest answer is: “we don’t have enough data to be confident. Here’s what more data would resolve.”

What this looks like in code

Simmis’s inference engine is Spindel, where a probabilistic model is an ordinary program with two extra effects — sample (draw from a prior) and observe (condition on evidence). It descends from the Anglican line of probabilistic programming; the distribution runtime (anglican.runtime) is a direct dependency.

require('[org.replikativ.spindel.spin.cps :refer [spin]]
  '[org.replikativ.spindel.inference.effects :refer [sample observe]]
  '[org.replikativ.spindel.inference.inference :as infer]
  '[org.replikativ.spindel.effects.await :refer [await]]
  '[anglican.runtime :refer [beta flip]])

;; A credence we can't read off directly — say, "the debt came due" —
;; starting from a prior and updated by each item in the record.
defn came-due []:
  spin(let [p sample(beta(2 2))]:
    observe(flip(p) true)
    observe(flip(p) true)
    observe(flip(p) false)
    p
  end)
end

;; Inference returns the posterior — a belief with error bars, not a verdict.
@spin(infer/query(await(infer/importance-sampling(came-due() 5000)) identity))
;; => {:mean 0.58 :std-dev 0.16 ...}

(require '[org.replikativ.spindel.spin.cps :refer [spin]]
         '[org.replikativ.spindel.inference.effects :refer [sample observe]]
         '[org.replikativ.spindel.inference.inference :as infer]
         '[org.replikativ.spindel.effects.await :refer [await]]
         '[anglican.runtime :refer [beta flip]])

;; A credence we can't read off directly — say, "the debt came due" —
;; starting from a prior and updated by each item in the record.
(defn came-due []
  (spin
    (let [p (sample (beta 2 2))]   ; prior over the credence
      (observe (flip p) true)      ; invoice dated and delivered
      (observe (flip p) true)      ; the agreed payment window elapsed
      (observe (flip p) false)     ; respondent disputes the due date
      p)))

;; Inference returns the posterior — a belief with error bars, not a verdict.
@(spin (infer/query (await (infer/importance-sampling (came-due) 5000))
                    identity))
;; => {:mean 0.58 :std-dev 0.16 ...}

The same sample/observe shape runs forward (simulation) or conditioned on real data (inference). It’s exactly what powers the legal dispute simulator, where each disputed element carries a credence like p above and the verdict is read off the posterior.

Bayesian inference is the mathematical form of good epistemic practice: hold beliefs proportionate to evidence, update when evidence arrives, and never confuse a best guess with a fact. Every answer comes with the uncertainty that’s actually there.

That’s more useful than a number. It’s a map of what the system knows, and doesn’t.

Further reading

• van de Meent, Paige, Yang & Wood, An Introduction to Probabilistic Programming (2018) — arXiv:1809.10756.
• The inference kernels — importance sampling, SMC, particle MCMC, BBVI — live in Spindel under inference/.