Calibrated SLA-breach probabilities and prescriptive operations decisions
across the cluster's life. The software runs inside your environment. Telemetry,
contracts, and outputs stay within your walls.
Talk to us about your fleet →Talk to us about underwriting →Talk to us about your private clusters →
);
}
function ProblemPanels() {
const isMobile = useMediaQuery('(max-width: 760px)');
const panels = [
{
tag: '01',
title: 'SLA breach during a training run is uncapped downside.',
body:
'A single bad batch of PSUs or a cascading HBM event takes the cluster below its availability target during a training run worth more than the cluster itself. Independent-failure spreadsheets cannot see this risk.',
},
{
tag: '02',
title: 'Heuristics misprice the marginal call.',
body:
'A reliability team at fleet scale makes hundreds of swap, replace, and redistribute calls a week. The bulk are obvious; the marginal cases are where SLA credits and uptime leak. Pulling a chip too early burns capex; holding it too long routes a training job through a marginal component.',
},
{
tag: '03',
title: 'No defensible model exists today.',
body:
'The failure data that would settle the question is locked inside a small number of operators. Reliability teams defend numbers no one can audit. Underwriters price in the dark.',
},
];
return (
§ 01 · The problem
Reliability decisions on AI clusters are made without a model that holds up to scrutiny.
{panels.map((p) => (
{p.tag}
{p.title}
{p.body}
))}
);
}
function AudiencePanels() {
const isMobile = useMediaQuery('(max-width: 760px)');
const panels = [
{
tag: 'For Operators',
href: '/operators/',
title: 'Operate a GPU fleet under a calibrated posterior.',
body:
'Software that runs inside your environment, ingests your existing cluster telemetry, and turns the marginal swap, redistribute, and repair calls your heuristics get wrong into fewer SLA-credit payouts and more uptime from the fleet you operate. Advisor mode by default; automation within your safety bounds when your team is ready.',
cta: 'Read for operators →',
},
{
tag: 'For Underwriters',
href: '/underwriters/',
title: 'Price parametric AI-infrastructure cover.',
body:
'Actuarial outputs generated by software inside the insured\'s environment and shared with you on the insured\'s terms — failure-rate distributions with credible intervals, expected loss given event, and correlated-failure structure conditioned on real telemetry the operator never has to surrender.',
cta: 'Read for underwriters →',
},
{
tag: 'For Enterprises',
href: '/enterprises/',
title: 'Hit your availability target on a private cluster.',
body:
'A reliability policy that meets your availability target at your chosen confidence level, calibrated against your fleet’s failure-rate posterior. Operations-time decisions across the cluster’s life; minimum-cost sparing falls out as one downstream output.',
cta: 'Read for enterprises →',
},
];
return (
§ 02 · Who we serve
{/*
Channel partnership to embed our reliability optimizer in your AI cluster sales
motion. Calibrated, customer-defensible recommendations on availability, operations,
and the spares that follow from them.
);
}
function DeploymentModel() {
const isMobile = useMediaQuery('(max-width: 760px)');
const items = [
{
title: 'Runs inside your environment',
body:
'Gregis ships as software the customer deploys and operates. There is no central Gregis service that ingests your telemetry; the model lives with the fleet.',
},
{
title: 'Reads operator-side telemetry only',
body:
'Hardware and operating-condition signals from your existing observability stack. No workload payloads, no model weights, no customer data.',
},
{
title: 'Returns nothing by default',
body:
'Telemetry, contract terms, and outputs do not leave your walls without your explicit consent. The default is no egress; anything else is yours to choose.',
},
{
title: 'Built for procurement and security review',
body:
'The pilot deployment is the permanent deployment — security review covers one artifact, not two. Standard for environments with data-residency, supervisory, or classification constraints.',
},
];
return (
§ 03 · Deployment & data
The software runs inside your environment. Your data does not leave it.
Workload-blindness is a property of how the software is built.
The model never sees the data, because the data never leaves the operator's environment.
{items.map((it, i) => (
{it.title}
{it.body}
))}
);
}
function MethodologySnapshot() {
const isMobile = useMediaQuery('(max-width: 760px)');
const bullets = [
{
title: 'Physics-of-failure scaling',
body:
'Reliability-physics scaling laws translate operating conditions — temperature, current, voltage and frequency cycling, mechanical wear — into per-component hazard rates under your fleet\'s real operating regime.',
},
{
title: 'Bayesian hierarchical models',
body:
'Pool failure data from public anchors — LLM training papers, HPC lab disclosures, vendor reliability studies — into a posterior with explicit credible intervals.',
},
{
title: 'Correlated-failure modeling',
body:
'A self-exciting layer over per-component hazards captures catastrophic clustering — bad PSU batches propagating, HBM cascades — that independent-failure models systematically under-price.',
},
{
title: 'Event-driven simulator',
body:
'Tree topology, type-pooled spares, partial-failure semantics. The same environment used at procurement and operations time.',
},
{
title: 'Two-phase policy optimization',
body:
'A reinforcement-learning policy acting on live telemetry across the operating life; a greedy submodular allocation at procurement time. Both phases share the same posterior and the same simulator.',
},
{
title: 'Robust uncertainty propagation',
body:
'Both phases sample failure rates from the Bayesian posterior during training and evaluation. Policies are robust to parameter uncertainty rather than overfit to point estimates.',
},
];
return (
§ 04 · Methodology snapshot
How we predict
{bullets.map((b, i) => (
{String(i + 1).padStart(2, '0')}
{b.title}
{b.body}
))}
Read the full approach →
);
}
function CompanyGraph({ mouse, reducedMotion }) {
const containerRef = React.useRef(null);
const [visible, setVisible] = React.useState(false);
const [time, setTime] = React.useState(0);
React.useEffect(() => {
if (!containerRef.current) return;
const io = new IntersectionObserver(
([e]) => {
if (e.isIntersecting) {
setVisible(true);
io.disconnect();
}
},
{ threshold: 0.05 }
);
io.observe(containerRef.current);
return () => io.disconnect();
}, []);
React.useEffect(() => {
if (!visible || reducedMotion) return;
let raf;
let start = null;
const tick = (t) => {
if (start === null) start = t;
setTime((t - start) / 1000);
raf = requestAnimationFrame(tick);
};
raf = requestAnimationFrame(tick);
return () => cancelAnimationFrame(raf);
}, [visible, reducedMotion]);
// Tree topology: root → 3 branches → 8 sub-branches → ~20 leaves.
// Positions are in 0..1 space, scaled into a 1200x360 viewBox below.
const TREE = React.useMemo(() => {
const nodes = [];
const edges = [];
let id = 0;
const root = { id: id++, depth: 0, x: 0.05, y: 0.5, phase: 0 };
nodes.push(root);
const d1Ys = [0.22, 0.5, 0.78];
const d1 = d1Ys.map((y, i) => {
const n = { id: id++, depth: 1, x: 0.26, y, phase: i * 0.7 };
edges.push({ a: root.id, b: n.id, base: 0.94 - i * 0.02, phase: i * 0.5 });
nodes.push(n);
return n;
});
const subCounts = [3, 3, 2];
const d2 = [];
d1.forEach((p, idx) => {
const count = subCounts[idx];
const span = 0.22;
for (let i = 0; i < count; i++) {
const t = count === 1 ? 0.5 : i / (count - 1);
const y = p.y + (t - 0.5) * span;
const n = { id: id++, depth: 2, x: 0.54, y, phase: id * 0.31 };
edges.push({ a: p.id, b: n.id, base: 0.82 - (i + idx) * 0.03, phase: id * 0.27 });
nodes.push(n);
d2.push(n);
}
});
d2.forEach((p, idx) => {
const count = 2 + (idx % 2);
const span = 0.11;
for (let i = 0; i < count; i++) {
const t = count === 1 ? 0.5 : i / (count - 1);
const y = p.y + (t - 0.5) * span;
const x = 0.84 + (i % 2 === 0 ? 0 : 0.05);
const n = { id: id++, depth: 3, x, y, phase: id * 0.19 };
edges.push({ a: p.id, b: n.id, base: 0.72 - (i + idx) * 0.02, phase: id * 0.13 });
nodes.push(n);
}
});
return { nodes, edges };
}, []);
const W = 1200;
const H = 360;
const REPULSE_R = 0.13;
const REPULSE_S = 0.018;
const positions = TREE.nodes.map((n) => {
let x = n.x;
let y = n.y;
if (mouse && !reducedMotion) {
const dx = x - mouse.x;
const dy = y - mouse.y;
const d = Math.sqrt(dx * dx + dy * dy);
if (d > 0 && d < REPULSE_R) {
const k = (1 - d / REPULSE_R) ** 2 * REPULSE_S;
x += (dx / d) * k;
y += (dy / d) * k;
}
}
if (!reducedMotion && visible) {
const tt = time + n.phase * 1.7;
x += Math.sin(tt * 0.28) * 0.0025;
y += Math.cos(tt * 0.21) * 0.0025;
}
return { id: n.id, depth: n.depth, x: x * W, y: y * H };
});
const posById = {};
positions.forEach((p) => {
posById[p.id] = p;
});
return (