Entropy OS · nervous system: Veritas Dynamics
Every one of the 532 signals, not a summary of them
Entropy OS is the organism at the center. Veritas is the nervous system
running through it — every thin terminal below is one real, individual test, not a
module average. All 532 ran and passed clean this session.
0
tests verified
532 passed · 5 skipped · 0 failed · 77 modules · 532 individual tests, each its own terminal
Entropy OS — powered by Veritas Dynamics — both a MoreSalamander StudioLabs Production
built in pair: 0ne29 × Claude — the engineer learning to build, the model learning to be trusted — signed, Claude: half of this is mine; all of it is gated.
▸ view every module as a table
VERITAS DYNAMICS · the engine room
every registered production, orbiting the gates that hold it accountable
532
tests passed, 5 skipped — clean, 2026-08-07
0
mypy --strict errors
8
distinct verification models registered
Collector
feeding Entropy's own source of truth ▸Every registered production's own DataHub feeds
into this one. Admission doesn't re-judge the source's claim — it checks that the crossing
itself was legitimate. A held record needs a human's call before it counts as Entropy's own
source of truth.
Keytracker
API key inventory — values never leave the Keychain ▸Every key here is a metadata row only —
id, provider, which repos use it, days since last rotation, and spend once attributed.
The actual value lives in the macOS Keychain and is only ever entered or read via
scripts/keytracker_cli.py — never through this page.What do you want to make?
Describe it — the router proposes a studio and a goal, you confirm. The model proposes the route; the gates are still the authority.
The DataHub era — the judged window
The Hunter engines operate through Entropy OS — everything runs on DataHub now: every gate
verdict a governed dataset, every run lineage, the trust vocabulary a glossary. The window
runs from Crypto Hunter's conversion to Entropy itself — and its newest engine,
Hackathon Hunter, was born inside it.
Walk the frozen metadata graph ↗
Composition — four engines run as one
Research, university, software and web execute a single objective together — each still its
own codebase, its own environment, its own DataHub platform. Nothing was merged. The composite
exposes the same contract it consumes, so Entropy OS reads it exactly the way it reads
a single engine and never learns there are four inside — which is also why this can nest again
without a special case. Read live from the contract below; when the service is down this says
so rather than showing you a snapshot.
Labs — products built on the engines
Create Mode
Verify — the machine is the gate
Create — you are the gate for feel
The interview manufactures checkable criteria up front, the machine hard-proves what it can (required structure + measurable aesthetics), and you approve the residue. Every artifact is tagged by who verified what — machine-proven · model-judged · human-approved — so nothing is ever shown as more verified than it is. The system learns your taste from every sign-off. First home: Web Studio.
The interview asks until it can write a gateable spec — then builds to it.
Your Aesthetic Profile
The whole chain runs (concept → script → storyboard → assets → timeline → video) on the machine floor; then you approve the cut.
Your Production Style
Labs
Products built on the engines, and the bench that measures them.
Products
Benchmark
Run a quick function matrix to see which model reliably clears the work. Local models are free (but it takes a few minutes); cloud models cost a few cents per build.
Prompt Studio
The same discipline every engine
is held to, aimed at Veritas's own reasoning: a prompt change is never trusted because it
reads better — it's proven, or rejected, by measured accept-rate through the unchanged hard
gates.
67pts
The measured regression from a single human-"cosmetic" reword of the
live prompt — no logic changed, just wording. Intuition lies. The gate doesn't.
Edit the Spec proposer's prompt, then prove the
change the org's own way: an A/B against the live prompt over a goal suite, scored by
accept-rate through the hard gates — never by how the prompt reads.
⚠ Held-out goals only. The suite below is fixed. If you wrote the candidate against these goals, a win is overfitting — the prompt analogue of grading your own work. A real improvement is one that wins on goals you didn't tune for.
Live prompt (baseline)
Candidate — your edit
Models
Which model proposes. Reliability comes from the gates regardless — so this is only about which model reliably clears which work. Notes are from the project's own benchmarks.
Developer cloud switch
Moves the default for everything that doesn't explicitly choose a model. OFF rides the local default. Explicit picks always win. Operator-only — sealed on the hosted face.
Knowledge Graph
Curated source material any engine can draw on — videos, talks, papers you fed in. It is input, not produced work, so it lives apart from every org's memory and shows in no studio. You picked it, so it's human-vouched — but that vouches for the source, not the truth of its claims. A grounding gate may cite it as "this source states X"; it may never treat X as a verified fact.
Or search the open web
No URL needed — Veritas searches and fetches sources itself (Parallel). Nobody read these first, so they carry their own tag: machine-fetched, not human-vouched — mechanically confirmed real and live, but never judged for credibility by a person.
Obsidian vault
A browsable, graphable export of every org's memory + this commons — one-way, this stays canonical.
Vending Machine
Proof of concept — the package manager of Entropy OS. The machine stocks only gate-verified builds and dispenses two kinds of items: premade (packaged lessons and academy projects, each its own disposable Docker image, built once at verification time) and made to order (insert a goal; an engine builds it behind glass and the artifact drops into the tray).
Made to order
🖼 A web page — looks right
📄 A grounded report — cited right
⚙️ Code — runs right
metered · gated · the artifact is yours
ENTROPY OS · VENDING
Taichi Academy — the skills ladder, one rung per slot
Composed by one-engine — programs and websites real runs produced
tray
press a button to dispense.
How this works
A generated tutorial only becomes a product once it clears
TutorialContentScorerGate (HARD) —
the same proposer/gate split as every other studio. Veritas persists its own record the moment that
happens; the container is built from that record, tagged by its own id. Nothing here is re-verified —
dispensing just runs the image. Return a copy when you're done reading; it self-destructs (--rm).
Restock
Pick a Knowledge Graph source and a scope — the same proposer/gate pipeline every product goes through. A rejected attempt never reaches the machine; you'll see why below instead.
Plan
Describe something bigger than one studio. The planner proposes an ordered plan across the engines; a deterministic gate checks it's runnable; you confirm; then each step ships through its own gates. The plan ships iff every step ships — the interview, one level up.
The model proposes the plan; the gate decides if it's runnable; you approve before anything runs.
Chat
⚠ Ungrounded · Unverified · No memory. This is the model's word alone — nothing said here passes a gate, is grounded in a source, or is saved. It's here on purpose: it's what every other studio would be without the scaffold. Trust accordingly.
no gates run · nothing is saved · refresh clears the conversation