HACKER NEWS EXCLUSIVE · FIRST-RUN · 100 / 100 SEATS LEFT

Bestowal — A Governed Cognitive Operating System

A Governed Cognitive Operating System.

Single file. Zero dependencies. Bestowal rewrites the source — any function, any language target — and hands back a governed artifact with a structured diff and a fingerprint. Powered by the CMPSBL® Cognitive Infrastructure Substrate.

reactor · livefp · a4f9…031b5c2a
verdict · allowartifact · signed

one-time payment · lifetime license · no subscription · no telemetry · no SaaS leash

charge.ts — payment handlerenforce mode · 5 layers
1 · raw source7 lines
async function chargeCard(amount: number, token: string) {
  const res = await fetch("https://api.stripe.com/v1/charges", {
    method: "POST",
    body: JSON.stringify({ amount, token }),
  });
  return res.json();
}
2 · governed artifact557 lines
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// CMPSBL® Ascension Layer — Governance Injected
// Layers applied: Circuit Breaker, Timeout Guard, Retry with Backoff, WITNESS — Audit-Chain Witness, Receipt Emitter
// Functions wrapped: 1
// Governance: baked=enforce, runtime override via CMPSBL_MODE
// U.S. Patent App. No. 64/029,678 · No. 64/031,637
// © CMPSBL® — All rights reserved.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// ── CMPSBL® Governance Mode Resolver ──
// Baked mode: enforce. Override at runtime with CMPSBL_MODE=observe|soft|enforce.
const __cmpsbl_baked_mode = "enforce";
const __cmpsbl_valid_modes = ['observe','soft','enforce'];
let __cmpsbl_effective_mode: 'observe'|'soft'|'enforce' = __cmpsbl_baked_mode as any;
(() => {
  try {
    const _env = (typeof process !== 'undefined' && process.env && process.env.CMPSBL_MODE) || '';
    if (!_env) return;
    const _norm = String(_env).toLowerCase().trim();
Circuit BreakerTimeout GuardRetry with BackoffWITNESSReceipt Emitter
fingerprint · 031b5c2apatents · 64/029,678 · 64/031,637run it live

Substrate · readout

The Substrate in Numbers

0
lines · single substrate file
0
layers · 10 pillars
0
behavioral engines
0+
polyglot targets · incl. HDL
0
runtime dependencies

What ships in the ZIP

Three artifacts. One distribution.
Built at the source, not the sidecar.

Pillar 01 · The Agent25 Crown Jewels · 76 layers · 233 discovered

A governed cognitive OS in one file.

cmpsbl-agent-bestowal.ts ships as a single 5,006-line TypeScript module with zero npm dependencies. Five behavioral engines — DEFENSE, CORTEX, NEXUS, BRAIN, ORACLE — chain into a Lex Gate that decides allow / deny / detach / quarantine / escalate before a single side-effect fires.

  • NEXUS multi-provider LLM router — 5 strategies, circuit breakers, cost tracking
  • ReAct reasoning loop · SSE streaming · OpenAI-compatible tool framework
  • Output Defense Gate: PII redaction, hallucination detection, response signing
  • FNV-1a tamper-evident audit chain — every action linked into a verifiable hash chain
  • executeProduction() — sandbox + human-approval gate + budget limits, fails closed
step01
Pillar 02 · The MachineTS · JS · Python in · 12+ out

Source-level governance, injected on command.

The Ascension V2 Wrapping Machine reads your TypeScript, JavaScript, or Python, finds the function ranges, and surgically injects governed pipelines around them. Three runtime-switchable modes — OBSERVE, SOFT, ENFORCE — let you ship the same file from staging to production by flipping one constant. Deterministic by construction.

  • Pattern-based function-range detection with structured before/after diffs
  • Polyglot generation across 12+ targets — 9 fully-shipping languages plus Verilog, VHDL & SystemVerilog
  • Pre-Ascension Gate rejects malformed or unsafe source before processing
  • Three governance modes: silent observation → console warnings → active enforcement
  • Fingerprint verification on every emitted artifact — byte-identical output, enforced
step02
Pillar 03 · The Library76 layers · 31 + 45

76 deterministic layers. 10 pillars. Phase-ordered.

The complete CMPSBL Layer Catalog — circuit breakers, contract validators, replay logs, witnesses, behavioral biometrics, neural brokers, sovereignty partitioners. 31 are auto-inlined on every export. 45 are à la carte. Every layer is a single file with zero deps and a documented composition order.

  • Resilience · Foresight · Security · Intelligence · Performance
  • Orchestration · Evolution · Governance · Compliance · Inventory
  • 31 always-on core layers — circuit breaker, retry, timeout, witness, audit
  • 45 selectable layers — adversarial wargame, honeypot intel, neural broker
  • Single-file distribution. Deterministic composition. No vendor lock-in.
step03

The pipeline

Five engines feed one Lex Gate.

Every task threads through five behavioral engines, then a Lex verdict, then a circuit-broken execution layer, then an auto-tiered audit chain. Deterministic. Replayable. Signed.

DEFENSE
scan · sanitize · immune
CORTEX
triage · budget · attention
NEXUS
route · health · cost
BRAIN
recall · episodic · SM-2
ORACLE
predict · converge · shadow
LEX GATE
allowobserveescalatequarantinedetachdeny
Circuit Breaker
isolated execution
Audit Chain
FNV-1a tamper-evident
Auto-tier Memory
episodic · SM-2 spaced

The developer experience

Two import statements. Production-grade governance.

use-as-agent.ts
import { createBestowableAgent } from './cmpsbl-agent-bestowal';

const agent = createBestowableAgent();

// Multi-provider routing — failover, cost-aware, circuit-broken
agent.addProvider({
  id: 'openai', name: 'OpenAI',
  baseUrl: 'https://api.openai.com/v1',
  apiKey: process.env.OPENAI_KEY!,
  defaultModel: 'gpt-4', models: ['gpt-4'],
  priority: 1,
  costPer1kInput: 0.03, costPer1kOutput: 0.06,
});

// Governed task — DEFENSE → CORTEX → NEXUS → BRAIN → ORACLE → LEX
const result = await agent.execute('analyze data', async (input) => {
  return { analysis: 'complete', confidence: 0.95 };
});

result.lexVerdict;     // 'allow'
result.auditHash;      // FNV-1a chain · tamper-evident
result.engineTrace;    // ['DEFENSE:continue', 'CORTEX:continue', ...]

// ReAct reasoning, SSE streaming, checkpoint / restore
await agent.streamAsk('Tell me a story', (c) => process.stdout.write(c.content));
agent.checkpoint('before-deploy');
agent.restore('before-deploy');
use-as-machine.ts
import {
  injectLayerWrapping,
  detectFunctionRanges,
  generateSourceDiff,
} from './ascension-v2/source-injector';

const ranges = detectFunctionRanges(myCode, 'typescript');
const result = injectLayerWrapping(
  myCode,
  'typescript',
  selectedLayers,
  ranges,
  'enforce',         // 'observe' | 'soft' | 'enforce'
);

result.wrappedSource;                              // your code, now governed
generateSourceDiff(myCode, result.wrappedSource);  // structured before/after
result.wrappedCount;                               // # of functions wrapped
Crown Jewel Manifest

25 named Crown Jewels.Selected from 233 discovered.

The shipped distribution is the surgically selected top of a multi-year private discovery program — deployed across 76 governed layers. Production-grade and in the box.

Explore the manifest
Sell Sheet · Free Download

The one-pager.Everything Bestowal is, at a glance.

A single-page brief covering the 76 layers, 25 Crown Jewels, the executeProduction governance loop, and what ships in the ZIP. No purchase required.

Why this one

If you're going to own one cognitive substrate
in your lifetime — own this one.

/ 01

Not middleware. A source transform.

Modern agent-governance toolkits sit next to your agent at runtime — policy SDK, sandbox, audit sink. Useful, but agent-scoped and call-site bound. Bestowal's Ascension Wrapping Machine rewrites the source itself: any function, any callable boundary — agents, payment handlers, parsers, IPC — comes back governed, with a structured diff and a fingerprint. The governance ships with the code, not beside it.

/ 02

Single file. Zero dependencies.

5,006 lines of TypeScript. No node_modules. No supply-chain surface. You can read it on a flight, audit it line by line, and ship it into an air-gapped network without a registry round-trip.

/ 03

Polyglot by design — 12+ targets.

TypeScript, JavaScript, and Python in. Nine fully-shipping languages plus Verilog, VHDL, and SystemVerilog out. Governance that doesn't care whether the thing being wrapped is a Node service, a Python worker, or an FPGA module. Most competing governance stacks ship one runtime SDK per language and stop there.

/ 04

25 named Crown Jewels — selected from 233 discovered.

The shipped distribution is the surgically selected top of a multi-year private discovery program: 25 named Crown Jewels, selected from 233 discovered, deployed across 76 governed layers. Production-grade and in the box; live vault sync arrives in v3. You are buying the result of a research program, not a weekend hack.

See all 25
/ 05

Provably deterministic.

Same input, same artifact, every run — enforced by the shipped test suite, not just claimed. 46 passing assertions across smoke (17), production-hardening (23), and Shield attack (6) suites. Re-run any time with `cmpsbl-bestow verify`. Hand a regulator the artifact and the hash.

/ 06

Patent-pending. Source-available. Yours.

U.S. Patent App. 64/029,678 and 64/031,637. CSAL-1.0 source-available license. One payment. Lifetime use. No SaaS leash, no telemetry, no kill switch.

Hacker News introductory price · before any other site

$49once.

First-run price. Flips to $139 the moment 100 seats are claimed.

Seats claimed0 / 100
100 seats remain at $49 · price flips to $139 at zero
  • Lifetime license · CSAL-1.0 source-available
  • All future v2.x patches · free
  • Re-download anytime · fingerprint-verified
  • No subscription · no telemetry · no SaaS leash
  • First-run cohort badge · etched in the manifest
License ladder · $49 first-run (first 100) $139 indie / source $499+ commercial (single company)

Counter is live · increments on every paid checkout.

CMPSBL-BESTOWAL-V2.1.3.zipdelivered
  • cmpsbl-agent-bestowal.ts5,006-line governed cognitive OS
  • ascension-orchestrator.tsPipeline state machine + governance-mode.ts
  • ascension-v2/ (8 files)Source-level wrapping machine — TS · JS · Python
  • cmpsbl-layers.tsLayer catalog barrel + phase ordering
  • layers/ (76 files)Complete CMPSBL Layer Library — 10 pillars
  • shield/Prompt-injection defense — degrades safely, never fails open
  • production/executeProduction · sandbox · approval · budget · receipts
  • polyglot/12+ targets — 9 languages plus Verilog · VHDL · SystemVerilog
  • nexus/ · runtime/engines/Multi-provider LLM router + 5 behavioral engines
  • test/ (3 suites)46 passing assertions · cmpsbl-bestow verify
  • docs/ + OWNERS-MANUAL.htmlQUICKSTART · INSTALL · GOVERNANCE · NEXUS · EXPORT · INTEGRATION-GUIDE
  • LICENSE.md · CSAL-1.0Source-available, perpetual
  • meta/PROOF.txt + manifest.jsonContent-fingerprint certificate
  • + CMPSBL-BESTOWAL-Sell-Sheet.pdfPrintable single-page summary (bonus)
06 — Questions

Everything you'd want to know before you click buy.

Plain answers on what's in the ZIP, how it's licensed, how to set it up, and who it's actually for.

01
What's inside the ZIP
4

02
Licensing & ownership
5

03
Setup & integration
5

04
Who it's for
4

Still have questions? hello@bestowable.com
Kenneth E. Sweet Jr.

The creator

Kenneth E. Sweet Jr.

Bestowal is the public form of a multi-year private research program — the CMPSBL® Cognitive Infrastructure Substrate. Two pending U.S. patents, and 25 named Crown Jewels selected from 233 discovered in an ongoing program — all under a single source-available license, in your hands.

© 2024–2026 CMPSBL® · U.S. Patent App. 64/029,678 · 64/031,637

The bestowal
is open.

100 of 100 seats remain. $49 once. The result of a multi-year research program — source-available, fingerprinted, and yours to keep.

Intellectual Property

U.S. Provisional Patent Applications

Both applications were filed with the USPTO by Kenneth E. Sweet Jr. in April 2026. Application numbers and titles are reproduced verbatim from the filing receipts.

U.S. Provisional App.
filed Apr 4, 2026
64/029,678

Dual-Layer Deterministic Software Evolution System for Autonomous Primitive-Based Code Hardening Without Source Modification

Covers the Substrate side — the runtime that hardens executing code through autonomous, deterministic primitive layers without rewriting the original source.

U.S. Provisional App.
filed Apr 7, 2026
64/031,637

Silent Symbiotic Software Attachment System with Integrated Governance Layer for Non-Intrusive Capability Enhancement Across Heterogeneous Computing Environments

Covers the Bestowal side — the source-level wrapping machine that attaches a governance layer to existing functions across languages and runtimes without changing their behavior.

Provisional status. Not granted patents. Pendency provides a 12-month priority window under 35 U.S.C. § 111(b).