What Bayescope does, and how to use it
A security-consultant platform that ranks the risks most likely to hurt you and shows the evidence behind every number — one methodology, five modules, on your network or ours.
What Bayescope is
Bayescope is an AI security consultant that shows its work. It builds a model of your environment, simulates how real attacks would unfold against it, and ranks what is most likely to happen to you — with a confidence interval on every number and a walkable trail from each probability back to the evidence that produced it.
It is built for two audiences: security consultants and vCISOs who deliver senior-analyst work across many clients, and regulated organizations whose data cannot leave their walls. The entire analysis engine runs on-premises, fully air-gapped, with optional local AI inference — nothing has to leave the building.
How it thinks — one methodology
Everything in Bayescope is one loop, applied to your security:
- Observe — build a live model of the environment: assets, identities, controls, exposure.
- Detect anomalies — find what doesn't fit the shape of a healthy environment.
- Identify the binding constraint — the single chokepoint that shapes risk the most.
- Adapt historical analogues — real incidents used as structural templates, not predictions.
- Generate scenarios — instantiate staged attack campaigns against your environment.
- Rank by Monte Carlo — simulate thousands of runs; rank by likelihood with confidence intervals.
- Act — recommend the change that reduces the most risk per euro, with the delta shown.
- Update — new evidence moves the posteriors; the loop closes and stays honest.
A single run of this loop is a cycle — an immutable, timestamped snapshot you can compare against past cycles to see how your posture moved and why.
Reading the numbers
Bayescope's whole promise is that its output is interrogable. A few conventions make it readable:
Probabilities and confidence intervals
Every scenario probability is drawn on the full 0–100% scale, never rescaled to flatter the data, so you can compare bars across scenarios and clients. Each carries a 90% confidence interval — the band, not just the point, tells you how much the estimate is worth.
The reasoning chain
Click any probability to open its chain: the prior it started from, each piece of evidence with its likelihood ratio, and the resulting posterior. This is the derivation you can put in front of a board or an auditor.
Control status — verified, attested, or unknown
A control is one of three states, never conflated:
- Verified backed by machine evidence from a connector (an EDR console, an identity provider). Carries an evidence reference.
- Attested a human claim — someone said it is in place. A document is a claim, not proof.
- Unknown no evidence either way. Absence of telemetry is never treated as absence of risk.
Getting started
You use Bayescope through its web console. Ask your administrator for an account, then sign in.
- Create a client Consultants add a client (an isolated tenant) from the console. Each client's data is walled off from every other — nothing crosses between them.
- Model the environment Populate assets, identities, and controls — by CSV import, by connecting a live tool (see Connectors), or captured from an interview. Mark crown-jewel assets and internet-facing exposure; those drive the analysis.
- Run a cycle The engine instantiates the scenario library against the environment, simulates it, and produces a ranked risk picture with reasoning chains.
- Read Assess and Advise Assess shows posture and compliance gaps; Advise shows the changes that reduce the most risk per euro.
- Sign off and export a report Draft a report from a cycle, sign it, and export it (PDF, DOCX, or JSON) — white-labelled to your practice.
The engagement workflow
A typical engagement follows the loop above, end to end:
- Baseline — model the environment and run the first cycle. This is your starting posture: ranked scenarios, a gap register, and a compliance picture against the frameworks that apply to the client.
- Advise — turn gaps into a funded roadmap. The optimizer ranks candidate initiatives by simulated risk reduction per euro and tells you the single change with the biggest effect.
- Re-run and compare — as controls are implemented or new evidence arrives, run another cycle. The cycle diff shows exactly what moved and by how much.
- Operate & Respond — for clients running live, triage alerts into cases and act through gated playbooks (see below).
Assess — posture & compliance
What it does: resolves your control posture and maps it to the regulations and frameworks that apply.
How you use it: the control register shows every control as verified, attested, or unknown, with freshness. The gap register ranks what's missing by its simulated contribution to risk — not by a severity label — so you fix what matters. Compliance views map controls to NIS2, DORA, ISO 27001, and CIS (country-specific packs included). You can attest a control, upload supporting evidence, and have an independent reviewer sign off on it — attestation and verification stay separate by design.
Advise — investment & roadmap
What it does: turns the risk picture into a prioritized, funded plan.
How you use it: add candidate initiatives, then move the budget slider to see which are funded and the risk each retires. The optimizer scores every initiative by risk reduction per euro across the whole scenario set — an initiative that reduces no measurable risk is never funded, however well it fits. "What should I invest in next?" surfaces the top open gaps by simulated risk. The SOC economics view projects analyst workload against measured trust metrics, and the adversary emulation panel (below) plugs its exposed-path findings straight into the ranking.
Emulate — adversary emulation
What it does: a generative adversary searches your environment model for routes to its objective, and ranks them — the defensive question no scanner asks: how many ways in does the attacker still have, and how cheaply?
How you use it: pick an adversary profile (ransomware group, nation-state, insider, and more) and run it. You get the signature metric — "N viable paths to compromise; M eliminated; K critical" — a per-crown-jewel path inventory, and the highest-leverage changes that close the most exposure. Every exposed path is a walkable sequence of technique-level steps with the controls at each. Output is strictly defensive: exposed paths and how to close them, never an attack kit. Adversary profiles are expert-reviewed content.
Operate — AI SOC analyst
What it does: turns a stream of alerts into triaged cases, with the AI recommending and the human deciding.
How you use it: alerts correlate into cases by fixed rules (no model). Enrichment is deterministic — asset criticality, scenario context, the SIEM investigation detail. The AI then recommends a disposition with an evidence-referenced rationale; it can never close a case on its own. An autonomy ladder lets an admin opt a specific alert class up to L1 (auto-close benign) only with a mandatory sampling review and the current accuracy shown at the moment of enablement. Trust metrics (accuracy, false-closure rate, MTTR) are computed from the case history and gate any promotion. Proactive hunts carry the exact SIEM query to run.
Respond — investigate & remediate
What it does: executes response playbooks against your tools — under strict, layered gates.
How you use it: playbooks are declarative and always offer a dry run that touches nothing. Live execution is gated three ways: the action must be on the tenant allowlist (empty by default), the playbook enabled, and the blast-radius tier satisfied — tier 0 auto only with explicit opt-in, tier 1 exactly one human approval, tier 2 refused. Every action shows a counterfactual pre-flight: the modelled effect of taking it, before anyone approves. Posture remediation closes a gap only when the control re-verifies through the normal path — a "ticket closed" claim is never enough.
Evidence & audit
Two guarantees make the output defensible:
- Every probability is traceable. Prior → evidence → likelihood ratio → posterior is persisted in an append-only trail. The Evidence explorer lets you walk any number to its derivation.
- Every simulation is reproducible. Each run stores its seed and complete input state. Given the same inputs, the result is bit-identical — for you, your auditor, and next quarter's you.
The audit trail is append-only and tamper-evident: nothing is edited in place, and a signed report is a sequence of immutable records, not a mutable document.
Connectors & live telemetry
Connectors let Bayescope observe instead of relying only on human claims. A connector to an identity provider, EDR, SIEM, or vulnerability scanner does three things: it upgrades controls from attested to verified with evidence, it populates assets and identities with provenance, and it feeds alerts that open Operate cases and move scenario posteriors.
Adding one
- On a client, open Connectors and add a platform from the catalog (~28 supported — QRadar, Splunk, Elastic, Entra, Defender, Sentinel, Okta, Tenable, Qualys, Rapid7 and more).
- Enter its endpoint and credential. Secrets are encrypted at rest and write-only — never displayed again.
- Use Test (no ingest) to exercise auth and mapping and preview what would be ingested, writing nothing.
- Enable it. Scheduled pulls run on a cadence; failures are isolated per connector and surfaced.
Reports
A report is assembled from an immutable cycle snapshot — never a live re-query — so what you sign is exactly what was true at that moment. The flow: draft from a cycle, review, sign off (the approver is recorded), then export. Export is refused until the draft is signed. You can export PDF, DOCX, or JSON, white-labelled with your consultant org's name and accent. A signed report can be formally voided with a reason, but never silently altered.
Running on-prem
Bayescope's default deployment target is your own hardware. The whole stack is a self-contained Docker Compose install on a single host, with no cloud-managed service in the critical path.
- Zero egress. The methodology engine works with no network access at all.
- Pluggable AI. The AI layer is optional and provider-agnostic — Anthropic, OpenAI, Gemini, a local model running inside the install (Ollama or vLLM), or off entirely. With AI off, AI features disable cleanly with an explicit message; they never fabricate output.
- Secure by construction. Secrets encrypted at rest, TLS at the edge, per-request CSP, rate limiting, tenant isolation enforced in code, and an append-only audit trail.
Operators: the deployment guide and wiring runbook shipped with your install cover install, upgrade, backup/restore, and connecting live tooling.
The guarantees
A handful of rules are enforced in the code itself — they are what make Bayescope different from a tool that hands you a score:
- The AI never sets a probability. All quantitative work is deterministic Python.
- Every simulation is reproducible — seed and full input state persisted.
- Every probability is traceable — prior → evidence → posterior, in an audit trail.
- Controls are verified or attested, never conflated.
- Multi-tenant isolation from day one — no query crosses clients without a reviewed reason.
- Content is data — scenarios, framework mappings, and regulation packs are versioned, expert-reviewed content, editable without a deploy.
- Assumptions are explicit — every prior, multiplier, and default is registered with a source.
- On-prem is the default — the engine works air-gapped; AI is pluggable.