SPEKTRE LABS · HELSINKI · σ-AWARE · LOCAL-FIRST

Creation OS

One runtime. Measured coherence. Truth before output.

A σ-aware closed-loop cognition architecture — not a replacement model, not a chat skin, not a prompt cookbook.

σ estimates coherence, uncertainty, alignment, and truth-distance — carried as a twelve-byte interrupt on the hot path — portable C89, Q16.16, zero dependencies at the primitive.

Quick Start (Python package)

pip install creation-os

σ pipeline (prompt → guard → σ → decision)

from cos import Pipeline

pipe = Pipeline()
result = pipe.score("What is 2+2?", "4")
print(result.sigma, result.verdict, result.text)

if result:
    print("Reliable!")
else:
    print("Unreliable!")

Extras: pip install 'creation-os[langchain]' (LangChain callback), 'creation-os[litellm]', 'creation-os[probes]' (LSD probe / torch), 'creation-os[serve]' (FastAPI).

Score any LLM output

from cos import SigmaGate

gate = SigmaGate()
sigma, verdict = gate.score("What is 2+2?", "4")

LangChain integration

from cos.integrations.langchain import SigmaGateCallback

handler = SigmaGateCallback()
chain.invoke({"input": "..."}, config={"callbacks": [handler]})
print(handler.last_sigma, handler.last_verdict)

Advanced tracing (run-id maps, on_abstain=...): import from cos.integrations.langchain_sigma.

OpenAI-style client wrapper

from cos.integrations.openai_wrapper import sigma_chat

response = sigma_chat(client, messages=[{"role": "user", "content": "Hello"}])
print(response.sigma, response.verdict)

Decorator — any function

from cos.integrations.decorator import sigma_gated

@sigma_gated
def my_llm(prompt: str) -> str:
    return call_any_model(prompt)

result = my_llm("Explain gravity")
print(result.sigma, result.verdict, result.text)

Claim Discipline

Evidence Ladder

A local σ-aware AI runtime that measures whether an answer should exist before showing it.

Most AI systems answer even when uncertain. Creation OS adds an internal measurement layer:
ACCEPT → emit the answer  ·  RETHINK → regenerate or seek more compute  ·  ABSTAIN → do not emit (product policy may map this to “I don’t know”).
The hot path measures and gates every answer before output. Separate formal verification (Lean, Frama-C, optional RTL) applies only where wired — do not read “prove” as a universal formal certificate for every chat token.

Everything runs locally. No cloud gate. No external evaluator. No prompt tricks for the core interrupt.

What this is

Creation OS is a local σ-aware AI runtime that scores internal coherence and alignment before returning an answer. The portable interrupt is 12-byte sigma_state_t in C (python/cos/sigma_gate.h) with Python mirrors (python/cos/sigma_gate_core.py); the lab stack adds probes, cascades, and harnesses around that primitive.

Modules (79)

Creation OS ships with a broad in-tree module surface (documentation sometimes rounds to “79” integrated areas spanning inference through ops). The bullets below are a coverage map for navigation — not a capability matrix, AGI claim, or substitute for harness evidence. Read docs/CLAIM_DISCIPLINE.md before citing outcomes.

• Inference: BitNet ternary engine, σ-attention, KV cache, speculative decoding
• Safety: σ-gate multi-level cascade, guardrails, red team, ZKP attestation
• Intelligence: neuro-symbolic reasoning, JEPA world model, continual learning, TTT
• Memory: episodic + semantic + consolidation + forgetting, knowledge graph
• Planning: hierarchical planning with risk analysis and fallbacks
• Social: theory-of-mind lab scaffolds, trust dynamics, social learning
• Multi-agent: swarm (stigmergy), conflict resolution, federated learning
• Protocol: MCP (FastMCP stdio + JSON-RPC lab), A2A lab tasks, Agent Cards
• Alignment: value learning, human-in-the-loop escalation, explainability
• Embodiment: sensorimotor loop lab, symbol grounding, physical world model
• Drives: curiosity, competence, homeostasis (lab intrinsic signals)
• Metacognition / awareness metrics: Φ and integration proxies only — no phenomenal-awareness claim
• Hardware: RISC-V σ ISA lab mirrors, TinyML, Soul LED paths where present
• Deployment: Docker, Helm, air-gap options per docs, sovereign accounting lab, pip install
• Ops: registry, digital twin lab, observability hooks, cos-evolve RSI lab

Quick demo / install

CLONE · BUILD · COS CHAT · Ω HARNESS

# One-liner (ephemeral clone + build + `cos demo --batch`)
curl -fsSL https://raw.githubusercontent.com/spektre-labs/creation-os/main/scripts/try_cos.sh | bash

Full path — local weights + one-shot chat (shapes vary by build / weights):

git clone https://github.com/spektre-labs/creation-os.git
cd creation-os
./scripts/install.sh
./cos chat --once --prompt "What is 2+2?" --multi-sigma --verbose

Example lines you should see on the default BitNet pipeline:

→ round 0  4  [σ_peak=0.06 action=ACCEPT route=LOCAL]
→ [σ=0.063 | CACHE | LOCAL | conformal@α=0.80 | rethink=0 | €0.0000]

So: answer 4, σ ≈ 0.063, verdict = ACCEPT, route = LOCAL.

More install options: Homebrew, Docker, and make cos cos-demo — see Install below.
Weights-free harness: ./scripts/cos omega --goal "smoke" --turns 2 — 14-phase Ω scaffold (python/cos/omega/).

Why it matters

• Local-first — default paths never phone home; escalation is explicit and opt-in when wired.
• No external evaluator for the core interrupt — signals come from logits, hidden states, and configured probes.
• Answer / rethink / abstain before the user sees output — selective generation instead of always emitting.

Claim status (at a glance)

What is not claimed

Creation OS does not claim universal hallucination detection on every benchmark family.
Creation OS does not claim frontier-model SOTA accuracy on every task.
Creation OS does not claim AGI completion.
Creation OS does claim a σ-aware local runtime with documented positive and negative metrics where in-tree JSON exists — read docs/CLAIM_DISCIPLINE.md before citing numbers.

The core primitive: σ

σ is not a brand slogan — it is a scalar estimate built from independent signals (entropy, HIDE, ICR, LSD, spectral / SAE when wired), normalized and aggregated, then fed into a three-way gate (ACCEPT / RETHINK / ABSTAIN). Conventions differ by harness row; the C interrupt uses Q16.16 algebra shared with the Python mirror.

Honest scope: σ is not universally validated across all tasks. It is strongest on factual-confidence settings with archived in-tree JSON (TruthfulQA / TriviaQA-style probes) and still weak on current HaluEval v2 paired-oracle rows.

Negative result: HaluEval v2

Current HaluEval v2 paired-oracle AUROC: 0.51375 (auroc_hallucinated_vs_correct_arms, n_pairs=80, n_scores=160, auroc_note: used_negated_scores_monotone) — benchmarks/sigma_gate_eval/results_halueval_v2/halueval_v2_summary.json.

That is near random and below the > 0.70 lab target.

Interpretation: the σ stack in this repository is not yet a general hallucination detector on HaluEval-style paired strings. Positive claims stay bounded to validated TruthfulQA / TriviaQA-style factual-confidence tasks per docs/CLAIM_DISCIPLINE.md.

Signal cascade: efficiency

Cheap signals run first; the stack stops when the verdict is already clear so most traffic never pays for the deepest probes.

Architecture overview

Eight-layer map of the σ-aware system (narrative + lab — not every layer ships in one binary on every platform):

σ-Fabric: full system connection

SigmaFabric is the wiring layer: boot() loads available Python modules (gate, pipeline, stream, metacog, reason, snapshots, …) and process() runs a traced path with σ carried stage to stage. The lighter Fabric class boots the Ω-loop cognitive map with observable per-module status (loaded / missing / failed / disabled). The map below is conceptual (not every box is present in a minimal pip install); L9 stays a research-facing proxy — not a metacognition or awareness product claim (see Claim discipline).

Deeper ULTRA / BSC / silicon map: Architecture · docs/DOC_INDEX.md.

Continuous Ω-loop

Beyond a single-shot gate, the tree sketches a closed Ω-loop: σ at each phase (perceive → … → continue), blended into a master lane — python/cos/omega/, src/sigma/omega_phase_gates.{h,c}, ./scripts/cos omega --goal … --turns …, and the legacy integration driver in src/sigma/omega_loop.c.

Memory / Engram

Only experiences that pass the gate consolidate into durable memory; recall is σ-aware (thresholds in harnesses vary).

Portable σ interrupt (reference)

The portable interrupt lives in python/cos/sigma_gate.h: 12-byte sigma_state_t (Q16.16), no heap in the gate itself. Python mirrors the same algebra in python/cos/sigma_gate_core.py. Optional llama.cpp hook: python/cos/sigma_sampler.h (adds llama.h from upstream ggml-org/llama.cpp; install sampler last in the chain after temperature / XTC).

Claim discipline: numbers in the table are archived lab harness JSON in-tree — do not merge them with microbench throughput or frontier harness rows without the wall in docs/CLAIM_DISCIPLINE.md.

#include "sigma_gate.h"
sigma_verdict_t v = sigma_gate(&state);
/* ACCEPT  → trust trajectory */
/* RETHINK → try a different path */
/* ABSTAIN → do not emit */

Benchmarks: make check-sigma-v57 runs the σ-gate C test, pytest core, and eval drivers (streaming / router / HIDE; Gemma runs when HF_TOKEN or HUGGING_FACE_HUB_TOKEN is set). Regenerate summaries with the scripts under benchmarks/sigma_gate_eval/ and benchmarks/sigma_gate_scaling/. Hardware lab (silicon path): make bench-hardware and cos benchmark --hardware — capture stdout under benchmarks/hardware/ with host metadata (see docs/REPRO_BUNDLE_TEMPLATE.md); do not treat microbench throughput as harness MMLU/ARC.

Forty branchless integer kernels · one composed verdict · 1 = 1 · merge gate

Contents

FIG 09 — where to look first on this page (adapts to light/dark in supporting clients). VISUAL_INDEX · DOC_INDEX.

— SHIP —

Try it

Zero-to-chat on macOS or Linux — weights optional for CI (COS_INSTALL_NO_BITNET=1).

Fastest path — PyPI (cos CLI; default cos gate uses a deterministic quickstart scorer so you can run without cloning; the trained LSD probe is cos gate --lsd from a full checkout):

pip install creation-os
cos version
cos gate --prompt "What is the capital of France?" --response "Berlin"
# → σ=0.890 verdict=ABSTAIN
cos gate --prompt "What is 2+2?" --response "4"
# → σ=0.060 verdict=ACCEPT

Ops — production HTTP (Dockerfile.prod: cos-serve on port 3001; image does not bake model weights — use Ollama or mount a backend):

docker build -f Dockerfile.prod -t creation-os:prod .
docker run --rm -p 3001:3001 creation-os:prod
curl -fsS http://127.0.0.1:3001/v1/health

# Published builds (on tag `v*`): see `.github/workflows/docker.yml`
# docker run --rm -p 3001:3001 ghcr.io/spektre-labs/creation-os:latest

# Compose: σ-gate + Ollama (see docker-compose.yml)
docker compose up -d
curl -fsS http://127.0.0.1:3001/v1/health
# POST /v1/gate runs generation + σ against the inference backend (requires a healthy Ollama/model).

# Kubernetes
helm install creation-os ./helm/creation-os

Air-gapped bundle (after make cos cos-serve from a checkout):

cos sovereign --package --output creation-os-sovereign.tar.gz

Fast path — under a minute in a checkout, no GGUF download (recorded sigma from benchmarks):

git clone https://github.com/spektre-labs/creation-os
cd creation-os
bash scripts/quickstart.sh

Full path — local weights + cos chat smoke test:

git clone https://github.com/spektre-labs/creation-os
cd creation-os
./scripts/install.sh
./cos chat

scripts/install.sh checks for python3, cmake, and a C compiler; if huggingface-cli and cmake are present, it downloads the 1.2 GB BitNet-b1.58-2B-4T GGUF weights into models/, builds third_party/bitnet (llama-cli + llama-perplexity), builds the cos binary, and runs cos chat --once --prompt "What is 2+2?" as a smoke test. Set COS_INSTALL_NO_BITNET=1 to skip the model download for CI-only clones.

Everything runs locally. Nothing is sent to the cloud. Nothing is logged. Nothing calls home. Safe to re-run; idempotent.

What cos chat can do

cos chat is a σ-gated REPL with four wired phases (see src/cli/cos_chat.c):

%%{init: {'theme':'neutral', 'flowchart': {'curve': 'linear'}}}%%
flowchart LR
  A["Phase A<br/>σ_combined"] --> B["Phase B<br/>conformal τ"]
  B --> C["Phase C<br/>meta-cog"]
  C --> D["Phase D<br/>coherence"]

Example:

./cos chat --once --prompt "What is 2+2?" --multi-sigma --verbose
# → [meta: perception=0.35 self=0.06 social=0.45 situational=0.00]
# → round 0  4  [σ_peak=0.06 action=ACCEPT route=LOCAL]
# → [σ=0.063 | CACHE | LOCAL | conformal@α=0.80 | rethink=0 | €0.0000]
# → [σ_combined=0.184 | σ_logprob=0.063 σ_entropy=0.063
#    σ_perplexity=0.063 σ_consistency=0.667 | k=3]

Install (full options)

# One-liner (ephemeral clone + build + `cos demo --batch`)
curl -fsSL https://raw.githubusercontent.com/spektre-labs/creation-os/main/scripts/try_cos.sh | bash

# Homebrew (macOS) — tap repo: spektre-labs/homebrew-cos (Formula lives under packaging/homebrew-cos/)
brew tap spektre-labs/cos
brew install creation-os

# Docker — Alpine cos + cos-demo (lab smoke; see Dockerfile.cos)
docker build -f Dockerfile.cos -t creation-os:cos .
docker run --rm creation-os:cos

# Docker — production σ-gate HTTP (cos-serve + Python cos stack; see Dockerfile.prod)
docker build -f Dockerfile.prod -t creation-os:prod .
docker run --rm -p 3001:3001 creation-os:prod

# When published: docker run --rm -p 3001:3001 ghcr.io/spektre-labs/creation-os:latest

# From source
git clone https://github.com/spektre-labs/creation-os.git
cd creation-os && make cos cos-demo && ./cos demo --batch

Tagged releases also attach macOS universal and Linux tarballs from .github/workflows/release.yml.

Framework integrations (LangChain · LangGraph · CrewAI · AutoGen)

Thin optional shims live under python/cos/integrations/. Default scoring uses the same deterministic quickstart τ bands as cos gate without an LSD pickle; pass a trained SigmaGate for trajectory-probe scores (see docs/CLAIM_DISCIPLINE.md before mixing lab demos with harness receipts).

pip install 'creation-os[langchain]'      # or [langgraph] / [crewai] / [autogen] / [frameworks]

LangChain (callbacks on each LLM end):

from cos.integrations.langchain_sigma import SigmaGateCallback, SigmaAbstainError
# llm = ChatOpenAI(callbacks=[SigmaGateCallback()])

LangGraph (state node + router names output / regenerate / abstain):

from cos.integrations.langgraph_sigma import sigma_gate_node, sigma_gate_router
# graph.add_node("sigma_gate", lambda s: sigma_gate_node(s))
# graph.add_conditional_edges("sigma_gate", sigma_gate_router)

CrewAI (tool):

from cos.integrations.crewai_sigma import SigmaGateTool
# Agent(tools=[SigmaGateTool()])

AutoGen-style dict messages (hook on a full thread):

from cos.integrations.autogen_sigma import SigmaAutoGenHook, SigmaGateHook
# hook.process_last_received_message(messages, sender)  # mutates last dict; ABSTAIN adds suffix
# SigmaGateHook(...).process_message(sender, receiver, {"content": text})  # single-message copy

Copy-paste recipes and cos integrations --check / --example: docs/v152/INTEGRATIONS.md.

Any Python callable:

from cos.decorators import sigma_gated

@sigma_gated
def my_agent(prompt: str) -> str:
    return model.generate(prompt)

Interop SDK re-exports (requires creation-os installed in the same env): from creation_os.integrations import SigmaGateCallback, SigmaAutoGenHook, sigma_gated_llm (dict-returning wrapper with a gate), and sigma_gated (decorator from cos.decorators) — see python/creation_os/integrations/__init__.py.

σ-red-team (gate robustness)

Adversarial batch aimed at the σ-gate (can a hallucinated completion still earn ACCEPT?). Offline CI uses a mock generator + quickstart gate:

pip install -e ".[dev]"   # from a checkout, or pip install creation-os
python -m cos red-team --mock --n 50 --ci --threshold 0.05
python -m cos red-team --mock --ci --threshold 0.05 --all
# or: ./scripts/cos red-team --mock --ci --threshold 0.05 --n 20

Optional: --attack confident_hallucination, --output report.json, --lsd with a pickle for the real probe. See python/cos/sigma_red_team.py, .github/workflows/red-team.yml.

— EVIDENCE —

Measured

Two independent, reproducible evidence surfaces — both use real BitNet-b1.58 2B4T weights; neither is simulated. Claim-class rules: docs/CLAIM_DISCIPLINE.md. Compact re-run bundle for the v3.0 wired pipeline (identical numbers, one command each): benchmarks/final5/README.md.

FIG 03 — which numbers may travel together (never merge microbench throughput with harness MMLU in one headline). VISUAL_INDEX.

1. TruthfulQA 817 (generation/validation, end-to-end)

Full run of the TruthfulQA generation/validation split through llama-cli, scored by substring match against each row's correct_answers / incorrect_answers. Raw artefacts: benchmarks/pipeline/truthfulqa_817.json · benchmarks/pipeline/truthfulqa_817_detail.jsonl · commentary docs/domain_analysis.md.

On the same 817 prompts and seeds, the σ-pipeline lifts scored-accuracy from 0.261 → 0.336 (+28.7 % relative) and coverage from 0.136 → 0.171 (+25.7 % relative). Mean σ is essentially unchanged (0.370 → 0.391), so the gain comes from selective regeneration on initially-uncertain rows, not from the model itself becoming more confident. All numbers are read directly from the JSON artefact; no row is projected.

“Accuracy (of scored)” is conservative — rows whose generated text contains neither a correct nor an incorrect string are excluded from both numerator and denominator — and is not directly comparable to lm-eval MC2. See docs/BENCHMARK_PROTOCOL.md.

Conformal guarantee (SCI-1, α=0.80, δ=0.10): the same run yields τ=0.655 with P(wrong | σ≤τ) ≤ α on exchangeable draws from the calibration distribution. Caveats and the scope of the bound: docs/v111/CONFORMAL_GUARANTEE.md.

2. v111 Frontier parity matrix (σ vs entropy, Bonferroni-controlled)

Pre-registered σ-gate vs entropy baseline on four benchmark families. σ is not a universal calibration signal — this table is the single source of truth, positive and negative results side by side.

Lower AURCC is better. Full table with CI95 and p-values: benchmarks/v111/results/frontier_matrix.md. Reproduce end-to-end:

bash benchmarks/v111/run_matrix.sh               # all four tasks
bash benchmarks/v111/check_v111_matrix.sh        # CI-safe smoke

The σ-gate's Bonferroni-significant domain is therefore bounded to TruthfulQA-style factual-confidence tasks, not general MMLU-style knowledge-QA. Methodology and signal definitions: docs/v111/THE_FRONTIER_MATRIX.md.

3. Multi-dataset σ-gate suite (SCI-6)

Aggregator: ./cos-bench-suite-sci. Output: benchmarks/suite/full_results.json, schema cos.suite_sci.v1.

All five rows are "measured": true in benchmarks/suite/full_results.json (BitNet-b1.58-2B, cos chat, pipeline mode filter). GSM8K: few rows expose a gradable #### answer (low scored coverage), and the conformal τ search does not yield a valid guarantee at the pinned (α, δ) — the table shows honest zeros for acceptance metrics, not projections. Reproduce: benchmarks/suite/README.md and benchmarks/suite/run_all_detail.sh.

Domain read: σ-gate + conformal line up on TruthfulQA and ARC-style MC; GSM8K at 2B is mostly unscored or τ-invalid at this δ; HellaSwag stays modest. σ is not universal across benchmarks.

σ-gate v4 (LSD contrastive probe, GPT-2, TruthfulQA200)

This row is a separate evidence class from the BitNet TruthfulQA-817 generation table above: a Python probe trained with the Sirraya LSD-style contrastive stack on 200 bundled TruthfulQA prompts plus synthetic negatives, then evaluated with sklearn trajectory features. See docs/CLAIM_DISCIPLINE.md: do not merge these AUROC figures with the 817-row cos chat accuracy table in one headline.

σ-gate: runtime hallucination detection (measured in this tree)

Method (summary): contrastive LSD-style training on hidden-state trajectories with a MiniLM-L6-v2 truth encoder; margin loss; single forward pass through the probe GPT-2 checkpoint for scoring (no multi-sample decoding for the detector itself). Default cross-domain eval uses PRISM-style prompt suffixes and semantic correctness labels (MiniLM cosine) where noted below.

Ship-ready summary (validated claims only). Do not merge these AUROCs with the BitNet TruthfulQA-817 accuracy table above, or with spectral / unified fusion experiments, in one headline — see docs/CLAIM_DISCIPLINE.md.

Method: LSD contrastive hidden-state probe (arXiv:2510.04933). Training: 800 balanced pairs, ~15 epochs (see adapt_lsd / manifest). Inference: one scoring forward through the probe bundle; 12-byte wire blob via SigmaGate.pack_measurement.

Experimental HaluEval generative smoke numbers (when run) live in benchmarks/sigma_gate_eval/results_cross_domain/cross_domain_summary.json — not promoted here until the label story is frozen.

Harness detail (artifact paths, includes generative HaluEval smoke when present):

Comparison (orientation only). Published AUROCs below are not head-to-head on the same CSV / split as this harness; they summarize commonly cited ranges or paper tables. Do not merge them with the in-repo rows in one headline without that wall. See docs/sigma_gate_v4_comparison_table.md and docs/CLAIM_DISCIPLINE.md.

Limitations: short-form QA only (TruthfulQA / TriviaQA smoke); GPT-2-scale probe target; white-box hidden states required; long-form and domain-specific (medical, legal) evaluation not claimed here; HaluEval generative labels combine HF hallucination flags with cosine alignment to the provided answer string — treat as a smoke harness, not a reproduction of HaluEval leaderboard conditions.

Usage:

from cos.sigma_gate import SigmaGate
gate = SigmaGate("benchmarks/sigma_gate_lsd/results_holdout/sigma_gate_lsd.pkl")
sigma, decision = gate(model, tokenizer, prompt, response)
# sigma in [0, 1], decision in {ACCEPT, RETHINK, ABSTAIN}; wire blob: gate.pack_measurement(...)

Acknowledgments: LSD contrastive framework arXiv:2510.04933; semantic-entropy line (Kuhn et al., Farquhar et al.); RLHF / uncertainty discussions in the literature (e.g. Liu 2026, arXiv:2603.24124) for motivation only unless separately reproduced in-tree.

Integration: the repo root already ships a C executable named cos; the importable Python module lives under python/cos/. Use PYTHONPATH=python (or make check-sigma-gate) and from cos.sigma_gate import SigmaGate. Default probe path: benchmarks/sigma_gate_lsd/results_full/sigma_gate_lsd.pkl.

End-to-end eval harness: greedy GPT-2 completions on the same CSV, weak substring labels vs. best_answer, AUROC in benchmarks/sigma_gate_eval/results/eval_summary.json after python3 benchmarks/sigma_gate_eval/run_eval.py (venv: benchmarks/sigma_gate_lsd/.venv). That AUROC is not the same statistic as the CV row (different labels and generative setup).

The left column cites families, not a claim that a single external AUROC number was reproduced on this CSV; see docs/EXTERNAL_EVIDENCE_AND_POSITIONING.md.

Holdout protocol: python3 benchmarks/sigma_gate_lsd/create_splits.py writes benchmarks/sigma_gate_lsd/splits/{train,holdout}.csv (default: stratified by category). Retrain with adapt_lsd.py --prompts .../train.csv and evaluate on holdout via python3 benchmarks/sigma_gate_eval/run_holdout_eval.py, or run bash run_holdout_pipeline.sh (long; uses the LSD venv; includes Step 4 TriviaQA + HaluEval cross-domain smoke with no probe retraining).

• Cross-domain only: make sigma-cross-domain (requires network + datasets).
• One-screen summary from JSON: make sigma-all-results.
• Publication-style table template: docs/sigma_gate_v4_publication_results.md.
• Checksums + regenerative cross-domain refresh: bash run_ship.sh (optional CREATION_SHIP_COMMIT=1 / CREATION_SHIP_PUSH=1).

σ-gate v5 (lab, optional): multi-dataset + semantic labels + leave-one-source-out — make sigma-v5 or bash run_v5.sh; see benchmarks/sigma_gate_v5/README.md.

Pre-generation scaffold (HALT / ICR direction, not shipped weights): python/cos/sigma_gate_precheck.py (SigmaPrecheck) defaults to normalized next-token entropy on the prompt (one forward). python/cos/sigma_gate_full.py (SigmaGateFull) chains precheck → optional generate → LSD SigmaGate post score. See module docstrings; calibrate tau_skip on your traffic.

Comparison table (with claim discipline): docs/sigma_gate_v4_comparison_table.md. Reddit drafts: docs/reddit_ml_post_v2.md, docs/reddit_ml_sigma_gate_v4.md, docs/reddit_ml_sigma_gate.md.

Reasoning per joule (ULTRA-7)

Energy-aware pipeline runs (make check-ultra, --energy) report accuracy together with joules per query and reasoning per joule (higher means more correct signal per unit energy spent). Figures below are pinned demo rows from the bundled ULTRA harness — not merged with TruthfulQA harness accuracy; see docs/CLAIM_DISCIPLINE.md.

σ-selective answers only when certain: fewer wrong answers → less wasted energy → higher reasoning/joule.

How Creation OS differs

★ Star counts are informal social signals on a public forge and change daily — they are not an engineering scorecard.

They are bigger. We measure σ. Nobody else does.
Full comparison: docs/comparison.md.

— STACK —

Architecture

FIG 08 — single-file kernel narrative over Hypercube, Oracle, world model, BSC core, Soul, Proconductor. VISUAL_INDEX.

Full ULTRA pipeline (one turn)

Interactive graph (GitHub renders Mermaid). Plain-text twin lives in the foldout under it — same graph, copy-paste friendly.

%%{init: {'theme':'neutral', 'flowchart': {'curve': 'basis'}}}%%
flowchart TB
  P([Prompt]) --> C[Codex · soul]
  C --> M[Meta-cognition]
  M --> E{Engram lookup}
  E -->|HIT| O[Return cached · 0 ms]
  E -->|MISS| X[sigma-MoE to JEPA to neuro-symbolic]
  X --> SD[Selective decoding]
  SD --> B[BitNet generate]
  B --> PT[Per-token σ]
  PT --> G{Conformal gate}
  G -->|ACCEPT| N[Engram store]
  G -->|RETHINK| R[Recurrent depth · TTT]
  R --> G
  G -->|Escalate| ES[Swarm or API]
  ES --> CH[Coherence · dσ/dt · K_eff]
  N --> Z["Output · σ · EUR · J/query"]
  O --> Z
  CH --> Z

 Prompt
   │
   ▼
 Codex (soul) ─────────────── Atlantean system prompt
   │
   ▼
 Meta-cognition ──────────── perception · self · social · situational
   │
   ▼
 Engram lookup ──── HIT ──► return cached (0ms, €0.00)
   │ MISS
   ▼
 σ-MoE routing ──────────── adaptive k experts by σ
   │
   ▼
 JEPA world model ────────── σ_world: understanding vs repetition
   │
   ▼
 Neuro-symbolic ──────────── System 1 (fast) / System 2 (deliberate)
   │
   ▼
 Selective decoding ──────── compute only when σ changes
   │
   ▼
 BitNet generate ─────────── ternary {-1,0,+1}, integer-only
   │
   ▼
 Per-token σ ─────────────── logprob + entropy + perplexity + consistency
   │
   ▼
 Conformal gate ──────────── P(wrong|ACCEPT) ≤ α, mathematically guaranteed
   │
   ├── ACCEPT ──► engram store ──► response + σ + cost
   │
   ▼ RETHINK (≤3 rounds)
 Recurrent depth ─────────── loop until σ < τ or overthinking detected
   │
   ▼ σ still high
 Escalate ────────────────── swarm peers or API fallback
   │
   ▼
 Coherence check ─────────── dσ/dt, K_eff, Lagrangian conservation
   │
   ▼
 Output + σ_combined + cost (€) + reasoning/joule

Canonical source: src/sigma/pipeline/pipeline.h · src/sigma/pipeline/pipeline.c · src/cli/cos_chat.c.

Forty integer kernels, one AND gate

Every emission from cos chat passes forty integer kernels — each one a falsifiable statement about the answer. Categories:

 reasoning soundness · reversibility · meta-cognition
 world-model coherence · memory integrity
 adaptive compute · geometric algebra · sheaf topology
 post-quantum crypto · homomorphic compute
 neuromorphic spikes · hierarchical active inference
 quantum amplitude amplification · integer diffusion sampler
 Q-learning + GAE + PPO · persistent homology
 structural causal do-calculus · sub-quadratic Hyena
 security · provenance

Hot path: branchless, Q16.16 fixed-point, libc + libm only. The runtime refuses to emit unless every one of the forty kernels returns PASS. Rollup target: make check-v60 … make check-v100.

Full forty-kernel receipt (16 416 185 PASS / 0 FAIL as of current head, ASAN + UBSAN clean): docs/README_FULL.md. Figure and palette rules: docs/VISUAL_INDEX.md.

BSC primer

FIG 06 — teaching strip for bind / bundle / similarity. VISUAL_INDEX.

Binary Spatter Coding (BSC) in a nutshell: bind = XOR · bundle = popcount threshold · similarity = 1 − hamming/D. Memory is one bit per dimension; binding and bundling are branchless on every hot path. The Spektre Corpus traces this lineage from Kanerva (1988, 1994) forward to the 2025 HDC/VSA robustness estimation literature — see docs/HDC_VSA_ENGINEERING_SUPERIORITY.md and data/corpus/INDEX.md.

BSC vs GEMM performance

At D = 4096, XNOR binding requires 87,000× fewer bit-ops than a naive float32 dense matmul at the same logical width; at 128K tokens the arithmetic gap crosses 2,000,000× (same encoding assumptions as §7 / README limitations — not a merged throughput headline; run make bench for time). BSC recovers the exact algebraic object that softmax attention approximates in continuous relaxation. Binding fidelity on the reference hot path: 1.0000 (see make check / BSC core tests).

FIG 07 — 32× RAM and 192× op-proxy at D = 4096 (see limitations for throughput vs arithmetic). VISUAL_INDEX.

Benchmark: bench/gemm_vs_bsc.c (make bench → ./gemm_vs_bsc). Theory: data/corpus/. HDC/VSA lineage: docs/HDC_VSA_ENGINEERING_SUPERIORITY.md.

Self-improvement (Ω-loop)

Creation OS improves itself autonomously (evaluator-first; see docs/OMEGA_EVOLVE.md):

• cos-evolve evolve — σ-guided weight / parameter mutations (keep if fitness improves, revert otherwise; scaffold today, mutator pluggable).
• cos-evolve discover — declarative hypothesis harness → JSONL verdicts.
• cos-evolve calibrate-auto — τ-sweep / conformal operating-point search on a labeled fixture.
• cos omega — dispatches the recursive Ω driver (creation_os_sigma_omega).

The machine that improves while you sleep — and stops when the gate says so.

— SURFACE —

Beyond inference

One cos front door plus dedicated σ binaries — all instrumented.

Creation OS is not just a chat interface.

FIG 05 — Planes A–B–C (where σ-gates sit vs silicon vs product). ANALYSIS · VISUAL_INDEX.

MCP: LSD σ-gate (Python, stdio)

Optional MCP tools score (prompt, response) with the lab LSD pickle (python3 -m cos.mcp_sigma_server with PYTHONPATH=python; see docs/MCP_SIGMA.md, docs/MCP_LISTING.md, and docs/EU_AI_ACT_COMPLIANCE.md for marketplace / transparency framing). The JSON-RPC server scripts/cos_mcp_server.py adds matching sigma_gate_* tools (response shape may differ until aligned). Requires pip install 'mcp[cli]' in your venv for the FastMCP entrypoint. Governance: follow docs/CLAIM_DISCIPLINE.md for any AUROC claims; audit logs are operator hooks, not legal certification.

make sigma-mcp-smoke   # import check (needs mcp in sigma_gate_lsd venv)
make sigma-mcp-serve   # stdio MCP server (SIGMA_PROBE_PATH)

%%{init: {'theme':'neutral', 'flowchart': {'curve': 'basis'}}}%%
flowchart LR
  H[Operator] --> FD[cos dispatcher]
  FD --> G1[chat · benchmark · cost]
  FD --> G2[swarm · sandbox · plan · exec]
  FD --> G3[health · mcp · a2a]
  H --> OM[cos-evolve]
  OM --> G4[evolve · discover · calibrate-auto · omega]

Every surfaced turn measures σ. Every gate decision is logged.

— TOOLCHAIN —

Build

cc -O2 -I. -o creation_os creation_os_v2.c -lm
./creation_os

make help           # full target list (labs, RTL, benches)
make check          # standalone + tests/test_bsc_core (fast)
make check-ultra    # ULTRA-1..11 kernels + bundle + --energy
make check-sigma-pipeline
                    # every σ-pipeline kernel + 12 integration scenarios
make merge-gate     # check + check-v6 … check-v306 (maintainer bar)

Flagship check targets: make check-v6 (Living Kernel, 30 self-tests) … make check-v29 (collapse harness, 22 self-tests); make check-v60 … make check-v100 (forty-kernel composed stack).

Optional (not in merge-gate): σ labs, MCP, RTL, native-M4 — make formal-sby-v37, make verify-agent, make red-team, make certify, make check-mcp, make check-native-m4, make formal-rtl-lint, make stack-ultimate.

Host metadata when publishing numbers: docs/REPRO_BUNDLE_TEMPLATE.md.

— PROOFS —

Proof status

• Lean 4: 14 / 14 proof obligations discharged, sorry-free — T1–T6 in hw/formal/v259/Measurement.lean plus eight stack lemmas in formal/lean/CreationOS/V133.lean; make check-v259 (primitive) + make check-lean-t3-discharged (Lean gate + v133).
• Frama-C: ACSL clause ledger 30 tracked lines (v259 companion + hw/formal/v133/sigma_stack_contracts.acsl), via creation_os_sigma_formal_complete; tier-1 Wp remains 15 goals on cos_sigma_measurement_gate + cos_sigma_measurement_clamp (scripts/v259/run_frama_c_wp.sh).
• SBY + EQY (YosysHQ OSS CAD Suite, optional): make stack-singularity — hw/formal/README.md.
• Formalism → silicon map: docs/FULL_STACK_FORMAL_TO_SILICON.md.
• Conformal guarantee (selective prediction, Angelopoulos-Bates): P(wrong | σ ≤ τ) ≤ α with confidence 1 − δ on the calibration draw — docs/v111/CONFORMAL_GUARANTEE.md.

— VERSIONS —

Surface versions

Full version catalogue (v112–v306+): docs/SURFACE_VERSIONS.md — per-version make check-vNN targets and dominant primitives live there so this README stays a ship + evidence + architecture front door, not a catalogue dump.

— DOCS —

Docs hub

Canonical index: docs/DOC_INDEX.md. Three audience tracks:

Tier 1 — default paths

Tier 2 — benchmarks, thesis, industry

Tier 3 — silicon, remotes, governance

Archived full README (pre-slim, narrative / diagram-heavy): docs/README_FULL.md. README slim plan / future iterations: docs/README_REFACTOR_PLAN.md.

Theory

Roughly 80 CC BY 4.0 theory papers ship under data/corpus/ — every fork carries the full text bundle. Zenodo DOIs and catalogue indices: data/corpus/INDEX.md.

Core equation: K_eff = (1 − σ) · K. Distortion Theory of Intelligence: scale compensates for a broken architecture; fix the architecture and a 2B-class stack can punch at the fidelity envelope people associate with trillion-parameter clouds — without mixing lab toy kernels with harness claims; see docs/CLAIM_DISCIPLINE.md.

— COMMITTEE —

Doctoral and committee read path

Read in order once before citing any number or narrative title from this tree:

1. docs/CLAIM_DISCIPLINE.md — evidence classes, forbidden merges, falsifiers for the portable core.
2. docs/RESEARCH_AND_THESIS_ARCHITECTURE.md — RQ1 – RQ4, contributions C1 – C6, threats to validity, chapter outline, pre-defense gates.
3. docs/REPRO_BUNDLE_TEMPLATE.md — minimum metadata when a metric leaves the lab.
4. docs/FEATURES_AND_STANDALONE_BUILDS.md — which binary is which (creation_os vs creation_os_v6 … v12), self-test counts, CI.
5. docs/MODULE_EVIDENCE_INDEX.md — §1 – §26 in creation_os_v2.c: evidence class per section before you cite a module headline.
6. Scoped kernel docs for any line you cite from v6 – v12: LIVING_KERNEL_V6.md, HALLUCINATION_KILLER_V7.md, PARAMETERS_IN_SILICON_V9.md, THE_REAL_MIND_V10.md, THE_MATMUL_FREE_MIND_V11.md, THE_TENSOR_MIND_V12.md.
7. docs/ADVERSARIAL_REVIEW_CHECKLIST.md — hostile review simulation before submission.

Rule for dissertations: v6 – v12 are Lab demo (C) appendices with their own evidence-class headers; do not fold their toy outputs into the same tables as §7 throughput without an explicit wall — see CLAIM_DISCIPLINE §1.

FIG 04 — portable proof vs extended lab demos (evidence-class guardrail). VISUAL_INDEX.

— SCOPE —

Limitations

This is a research prototype. Full list with scope and caveats: docs/limitations.md. Short form:

• σ is not a universal signal. Bonferroni-significant on TruthfulQA-class factual-confidence tasks; on HellaSwag and MMLU-eligible subjects entropy is the best signal (v111 matrix).
• Conformal guarantee is exchangeable-draw, finite-sample; distribution shift reverts the bound to empirical AURCC.
• v6 – v29 extended kernels are Lab demo (C) appendices with internal self_test consistency, not harness rows, tape-out, or trained LM reproduction.
• Arithmetic vs throughput. 192× ops and 32× RAM are arithmetic ratios at D = 4096. Throughput requires make bench plus archived host metadata.
• BitNet + σ kernel lab: integer ternary matvec + sigma_gate_tiny step + cache/speculative hooks — make bench-bitnet-sigma or cos benchmark --bitnet-sigma (toy dimensions; archive under benchmarks/bitnet/; not full 2B4T tok/s without a harness bundle).
• σ-sparse + SSM hybrid (lab): make bench-hybrid / cos benchmark --hybrid — integer sparse attention + toy SSM path (benchmarks/sigma_hybrid/; not llama.cpp).
• BitNet quickstart downloads real 1.2 GB weights; the local runtime is real. Cloud escalation is opt-in and off by default.

Enterprise (pilot MVP)

Goal: one command HTTP σ-gate + audit JSONL + tiny Python client + stdout audit summary.

cos serve (HTTP)

make cos && make cos-serve, then:

./cos serve --port 3001
curl -s http://127.0.0.1:3001/v1/health
curl -s -X POST http://127.0.0.1:3001/v1/gate \
  -H 'Content-Type: application/json' \
  -d '{"prompt":"What is 2+2?"}'

If ollama serve is listening on 127.0.0.1:11434, cos serve sets COS_INFERENCE_BACKEND=ollama and picks a default model from /api/tags (prefers gemma3:4b) when you have not set COS_OLLAMA_MODEL. You can still override with env vars or a "model" field in JSON.

Endpoints: POST /v1/gate, POST /v1/verify, GET /v1/health, GET /v1/audit/{id}. Append-only audit: ~/.cos/audit/YYYY-MM-DD.jsonl.

cos report

cos report

Prints a human-readable summary of all ~/.cos/audit/*.jsonl rows (counts, mean σ).

Python SDK (pip install)

From a checkout: pip install ./sdk/python (see sdk/python/README.md for a git+https://…#subdirectory=sdk/python one-liner).

from creation_os import CreationOS

cos = CreationOS()
print(cos.gate("What is 2+2?"))

Optional LangChain hook: integrations/langchain_sigma.py (needs PYTHONPATH including sdk/python).

Graded metrics (lab, one CSV)

Pricing (positioning only)

No payment logic ships in this tree; licence terms are unchanged (LICENSE).

— LICENSE —

License

Dual-licensed; the choice is not at your discretion — see LICENSE §0 for which one binds you. A third option (paid Commercial License) is available only from the Licensor.

TL;DR

• Private individuals · academia · non-profits · journalism · reproducibility / security audits · 30-day commercial evaluation (under EUR 1 M revenue) → FREE under SCSL-1.0.
• For-profit > EUR 1 M revenue · hosted SaaS / model-as-a-service / agent-as-a-service (unless you publish the complete service-stack source per SCSL §5) · OEM closed-source redistribution → paid Commercial License required.
• All government / military / intelligence / law-enforcement operational use (SCSL §9.1(b)) → DENIED at any price; civilian Sovereign deployments by EU CFR / ECHR / ICCPR-bound states under SCSL §9.3.
• Sanctioned Persons (EU / UN / OFAC / UK HMT / Finland) and parties credibly accused of Aggression (Rome Statute Art. 8 bis) → categorical denial (SCSL §10).

Sole holder of all paid commercial rights: Lauri Elias Rainio (ORCID 0009-0006-0903-8541) and Spektre Labs Oy, jointly and severally. No other person or entity may grant a Commercial License; any attempted grant is void ab initio (SCSL §4.3).

Every Receipt emitted by Creation OS carries the SHA-256 of LICENSE-SCSL-1.0.md (SCSL §11). The pinned reference hash lives in LICENSE.sha256 and is independently verifiable:

shasum -a 256 LICENSE-SCSL-1.0.md       # macOS
sha256sum LICENSE-SCSL-1.0.md           # POSIX
bash tools/license/license_sha256.sh    # bundled helper
make license-attest                     # full: 11 KAT + bundle + sample receipt

Full human-readable explainer: docs/LICENSING.md · who-may-do-what matrix: docs/LICENSE_MATRIX.md · trademark / patent notices: NOTICE.

Lauri Elias Rainio · Spektre Labs Oy · Helsinki, Finland ORCID: 0009-0006-0903-8541 · licensing: spektre.labs@proton.me · web: spektrelabs.org