// Variant C — GTO Wizard G1 style. // "Serious tool for serious operators". Product screenshot dominates the hero, // compact/dense sections below, purple on near-black, extra motion. function LandingC() { return (
); } // ─── Nav function NavC() { return ( ); } // ─── Hero — the big product screenshot is the visual function HeroC() { const tabs = [ { key: 'console', label: 'Operator console', hint: 'tx detail · verdict · layers' }, { key: 'txns', label: 'Transactions', hint: 'live streaming view' }, { key: 'block', label: 'Blocklist', hint: 'rules editor' }, ]; const [active, setActive] = React.useState('console'); const [hovered, setHovered] = React.useState(null); // Auto-rotate every 6s unless hovered React.useEffect(() => { if (hovered) return; const iv = setInterval(() => { setActive(a => tabs[(tabs.findIndex(t => t.key === a) + 1) % tabs.length].key); }, 6000); return () => clearInterval(iv); }, [hovered]); return (
DIPOLI / DECISION ENGINE · v3.2 · SOC 2 · PCI-DSS · GDPR

Three-layer transaction defense,
built for operators who can't be wrong.

Rules, Model α, Model β. Every transaction scored by all three in under 60ms. No black box. Every verdict explained, auditable, reversible.

No card · Full API · Sample data included
{/* Tab bar above the shot */}
{tabs.map(t => ( ))}
auto-rotating
{/* The big product shot */}
setHovered(true)} onMouseLeave={() => setHovered(false)} >
{active === 'console' && } {active === 'txns' && } {active === 'block' && }
{/* KPI strip under the shot */}
p50 end-to-end verdict
uptime · last 12 months
transactions scored / year
false-block rate · rolling 30d
); } // ─── Logo strip function LogoStripC() { const logos = ['INXY', 'Lumen Labs', 'Nimbus Pay', 'Acme EU', 'Parallax', 'Hartwick', 'Merido', 'Blockwell']; return (
Deployed by payment platforms processing $48B/yr
{logos.map((l, i) => ( {l} ))}
); } // ─── Bento — dense "what it does" grid function BentoC() { return (
01 · WHAT IT DOES

Not a model. A chain of defenses.

Every transaction is scored by rules, then two independent AI models that must either agree — or escalate to a human with a written reason.

{/* Big feature: 3-layer engine */}
L1 + L2 + L3
Three layers. One verdict. Every transaction.
Rules catch the obvious. Model α scores context. Model β breaks ties with a written rationale. Disagreement triggers a human, not a coin flip.
{/* Latency */}
LATENCY
p50 · full chain
p99 at 82ms. Under budget for inline scoring on every major processor.
 {/* Explainability */}
EXPLAIN
Every block has a reason, in plain English.
Model β writes the narrative. Feature contributions attached. Regulators and angry customers get the same clean answer.
BLOCK · 92 "Destination first seen 14 days ago on unrelated tenant. IP matches known laundering ring cluster. Escalation recommended."
{/* Reversible */}
REVERSIBLE
Every decision is a rollback away.
Replay any verdict against a new rule set or model version. A/B the chain on historical traffic before you ship.
v3.2current
v3.1shadow
v3.0archived
 {/* Inline */}
DEPLOY
One endpoint. Drop in before authorization.
Single REST call. SDKs for Node, Python, Go, Java.
POST /v3/decide
→ {`{ "verdict": "BLOCK", "score": 92,`}
{` "layer": "L1", "ms": 4 }`}
{/* Audit */}
AUDIT
Every layer, every feature, every millisecond — logged and queryable.
SOC 2 Type II. PCI-DSS 4.0. GDPR. Your auditor gets a read-only tenant, not a dance.
{['SOC 2 Type II', 'PCI-DSS 4.0', 'GDPR', 'ISO 27001', 'HIPAA-ready', 'FINRA'].map(c => ( {c} ))}
); } // Mini flow used inside the bento wide cell function LayerFlowMini() { return (
{[ { n: 'L1', label: 'Rules', t: '3ms', c: '#63D4E6' }, { n: 'L2', label: 'Model α', t: '14ms', c: '#9387FF' }, { n: 'L3', label: 'Model β', t: '22ms', c: '#81A8FF' }, ].map((l, i) => (
{l.n} {l.label} {l.t}
{i < 2 && (
)} ))}
VERDICT 39ms
); } // Latency sparkline under the bento stat function LatencyChart() { const data = [42, 38, 45, 41, 39, 47, 40, 38, 36, 41, 43, 39, 37, 40, 38, 39]; return (
{/* target band */} {(() => { const max = 50, min = 30; const pts = data.map((v, i) => { const x = (i / (data.length - 1)) * 240; const y = 60 - ((v - min) / (max - min)) * 54 - 3; return x.toFixed(1) + ',' + y.toFixed(1); }); const path = 'M ' + pts.join(' L '); return ( <> {data.map((v, i) => { const x = (i / (data.length - 1)) * 240; const y = 60 - ((v - min) / (max - min)) * 54 - 3; return ; })} ); })()} target < 50ms
); } Object.assign(window, { LandingC, LayerFlowMini, LatencyChart });