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 ↗
The in-house era — the early engines
The five verification models Veritas grew up on, with their original in-house data stores —
fully operable from here, clearly earlier.
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
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