A small studio building software, games, and creative work under one methodological commitment: AI does the high-volume synthesis under human-owned constraints, with verification at every boundary. The model proposes. Python disposes.
Everything below this section is the year-long record of how this got here. This is where it actually stands: a trust-governed runtime with real structure, not just a name given to a growing pile of projects.
Kernel = Veritas — every claim gated, nothing accepted on judgment alone. Processes = disposable containers, spun up and killed. Package manager = the vending machine of reusable AI.
Not the naming coincidence dressed up — the actual open-source metadata platform, running locally, holding this studio's real relationships, lineage, and provenance.
A vending machine of disposable AI engineering: reusable primitives dispensed as verified, one-time, throwaway goods — not a subscription, a good you buy, run, and keep the output of.
MoreSalamander is a personal studio organizing a body of work — software, tools, games, videos, simulations — under a shared methodological frame, instead of shipping each project as a standalone artifact with no connecting thread.
That's the honest version, and it's the reason the work hangs together: the body of work to date is the public record of that learning, in approximate chronological order.
Every MoreSalamander project is built on the same underlying principle: a well-fenced model inside a deterministic scaffold becomes reliable as a system, because the unreliable component is wrapped in reliable ones that decide whether to trust each output — when to retry, when to skip, when to score, when to commit.
In production-LLM circles the pattern goes by names like compound AI systems, guardrails, or constrained generation. Here it was earned through specific failures and codified into explicit doctrine.
Write the constraints before any AI synthesis happens. Constraint documents, schemas, scoring rubrics, series style guides. These are the doctrine. The model works inside them — it never edits them.
Let the model do the high-volume work — drafting prose, generating images, writing code, composing narration. The model is one component in the system, not the whole system.
Wrap every model output in pure Python that decides whether to trust the result. The grader can never be an LLM — because the grader cannot be the thing it grades. Reject what fails. Score what passes. Persist only what survives.
The thesis isn't a design preference picked up from a book. It has two origins, each traceable to a specific project — and the combination of the two is what the Deterministic Scaffold encodes.
Building the Build It Publisher (a six-stage n8n workflow, Jan 2026) forced the discipline: named stages, one responsibility each, explicit data flow. That shape got re-encoded in code, project after project, and later re-emerged as NDJSON event streams. It tells you how a system is structured.
MyMaestro, the first study tool, hallucinated — plausible wrong content into a learning aid, which is worse than nothing. The fix was architectural: verification has to be a load-bearing layer, not a soft warning at the UI. It tells you what every stage must do before it persists.
The methodology didn't come from a paper. It came from building the Build It Publisher and then watching MyMaestro hallucinate two months later. Both lineages are visible in every project the studio has shipped since.
The body of work didn't accumulate randomly; it converged. Eight months of preceding projects each contributed a lesson that became a piece of my-AI-stro: three coexisting named pipelines on one shared event vocabulary, a grounding gate at every persistence boundary, a deterministic (not-LLM) judge in a self-improving audit loop, and trust isolation across local models. It is the entire thesis operating as a working system, end-to-end auditable by anyone who reads the source — the reference implementation of the methodology.
Where my-AI-stro is the methodology realized as a full system, The House Always Wins is the same verification discipline realized as real-time game AI — every decision auditable at every frame. The crowning jewel and the live demonstration: two projects, one thesis, different shapes.
my-AI-stro proved the thesis as one system: a single deterministic scaffold wrapped around one body of work. The arc that follows it asks a different question — what happens when the scaffold itself gets pulled out of any one project and made into something other projects plug into. Three more names mark that generalization, each a checkpoint, not a new idea.
Started 2026-06-09. The moment "verify at every boundary" stopped being
a discipline re-implemented per project and became a literal reusable
substrate — Artifact / Gate / Memory
/ Run / Executor primitives, under one hard
invariant: zero gates can ever accept on judgment alone. Proven by building
three genuinely different verification models — software (execute the code),
web (render in a real browser), research (ground every claim in a pinned
source) — on the exact same unchanged engine. Later phases added a
human-approval tier for the one thing that can't be gated deterministically
(taste), and closed the loop with a literal bootstrap: the org used its own
gates to accept a real piece of its own engine, built by itself.
It's the thesis made into infrastructure — the capstone of this arc the way my-AI-stro is the crowning jewel of the last one.
Shipped 2026-07-18. The same invariant, reimplemented independently, under real stakes: real money, and real scams actively trying to get past the gate. It doesn't run on Veritas's engine code — it was hand-built in parallel, which is the point: the pattern held up outside the substrate, under pressure, before it was proven inside one. It was later bridged into Veritas as its first external org — Veritas reads Crypto Hunter's already-gated verdicts read-only; it never re-decides anything.
~15 named agents across scouting, verification, intelligence, and strategy, behind one deterministic fail-closed gate. Also the moment local-first stopped being the whole story: everything before it ran free and local to learn the scaffold cheaply; here, real stakes made the frontier spend (Claude Opus 4.8) worth it.
Shipped 2026-07-24. "An agent organization of agent organizations."
Where Crypto Hunter is an engine built from agents, Opportunity is an
engine built from engines — it reads the verified output of
Crypto Hunter, Collectible Hunter, and Free Money Hunter (three
independent domain engines sharing one extracted
hunter-engine package) and arbitrates a single time/money
budget across all three at once, live-validated on real merged data
the same day it shipped.
The next unstarted increment: an LLM-driven cross-org debate layer arguing priority across engines, not truth — each engine's own gate already settled that.
Every agent in the Crypto Hunter / hunter-engine / Opportunity lineage
writes candidate specs, evidence, and verdicts through one deterministic
store — no agent ever writes to disk directly. That single-writer
discipline is what makes the rest of the recursion possible:
settle_debate can re-run the gate because evidence lives in
one place; Opportunity's bridge can read three engines' verified queues
read-only because each engine already centralizes its state
behind one DataHub-shaped store — hunter-engine's literal
DataHub, and Opportunity's own OpportunityHub,
the same discipline one level up. (Veritas's own equivalent predates
this naming and is called MemoryStore — same role,
different lineage, same invariant.)
The name wasn't arbitrary, and it isn't backward-looking either. DataHub is the natural information medium for a deterministic agent engine to communicate through — one auditable channel every agent reads and writes, instead of ad hoc calls between them. That's the pivotal, forward direction for how this family of engines exchanges information going forward, not just how the last three happened to be built.
Every engine in this lineage already centralized its state behind one deterministic
store — hunter-engine's literal DataHub, Opportunity's own
OpportunityHub — the exact shape a real metadata catalog is built for. As of 2026-07-31, that convergence stopped
being a naming echo and became the real
DataHub product, built
out across nine full stages, not a single dataset bolted on:
schemas + business glossary
engineering graph
execution lineage
artifact identity
opportunity intelligence
agent observability
org-wide graph
deterministic workflow
metadata OS
Comparing gate-determinism data across orgs live in the graph: research (grounding claims against pinned sources) is the one org where gate failures outnumber passes — 13 passed against 19 failed, only 1 of 5 runs accepted — while software/production/web all clear over 80%. Not asserted from the architecture description; measured from the studio's own real run history, queryable the same way twice, by anyone.
Not a checklist cleared for its own sake — each stage is a different question the graph can now answer, built on real data, live-verified against the running instance before being called done.
Tracks: a governed vocabulary — HardGate/SoftGate/HumanGate as defined glossary terms, not bare labels; real schema documentation with a version + hash. Matters because: every later stage inherits meaning instead of reinventing it per dataset.
Tracks: real repos, all 64 hub API routes, packages, containers, infra, model routing, prompts, the first CI pipeline this stack has ever had. Matters because: a future container knows exactly what it's plugging into before it's built.
Tracks: which model produced a claim, what context was retrieved, confidence, the actual response. Matters because: any output traces back to what informed it — a receipt, not "trust me."
Tracks: real timestamps, parent-chain dependencies (artifacts are immutable, so the chain is version history), structured test evidence. Matters because: full derivation is walkable — where this came from, not just that it exists.
Tracks: category, difficulty, cost, value, risk, verification, expiration on every real opportunity an engine finds. Matters because: "verified, zero-cost, under 30 minutes" is a real query today — and the same shape fits whatever an engine hunts next.
Tracks: real success/failure rates, latency, cost, and gate-rigor distribution per agent and org, computed from real run history. Matters because: "which part of me is actually struggling" gets a measured answer, not a hunch.
Tracks: real edges — repo → API → agent → prompt → model → deployment → docs → tests. Matters because: when one container's output becomes another's input, this is what proves the handoff happened and traces it if something breaks.
Tracks: every real run's full lifecycle as ordered, timestamped stages — not one collapsed accepted/rejected flag. Matters because: reproducibility stops being a claim and becomes a query anyone can run.
Tracks: two independent systems already publishing into one shared graph, each still owning its own operational data. Matters because: this is the actual mechanism that lets the studio's tools compose without becoming one monolith.
Entropy OS, powered by Veritas Dynamics AI — not another AI agent racing to do more, but the trust layer underneath the ones that are: one deterministic invariant, independently rediscovered across nine shipped systems and proven live, holding up a portfolio of narrow, domain-gated engines instead of one agent trying to do everything. A MoreSalamander StudioLabs Production.
This whole arc — plus the checkpoints before and after it, cited with commit hashes, test counts, and live-run costs rather than asserted — is written up as a working paper: The deterministic scaffold: a case study in compounding architecture. → Read the paper ↗
Every tool runs the same underlying pipeline: named stages with explicit data flow, a shared NDJSON event vocabulary, and a gate at every boundary that decides whether to trust the model's output. The domain changes; the shape does not. (Each project's own pipeline lives on its page.)
Every stage in every pipeline emits the same events, so any tool's output can be observed, logged, and streamed to a UI with the same listener — the vocabulary never changes across tools.
step_start
step_complete
gate_pass
gate_fail
retry
fallback
skip
token
done
error
Hard pass/fail. A blocking failure stops the pipeline — the model retries within a bounded limit, then falls back or halts. These protect correctness, structure, and continuity.
Soft failures. A non-blocking failure drops the enhancement and continues — a missing music bed, a low-scoring visual that falls back to neutral. The premise survives; the extra is optional.
Engineering work — where the deliverable is a running system, a codebase, a product. Shipped under explicit constraint documents (Constitution, ARCHITECTURE.md, SPEC.md) that codify what the AI is and isn't allowed to do during development. The methodology encoded in code.
Creative work — videos, performances, comedy. The same explicit-constraint pattern applied to creative output: detailed shot, narration, and music specifications passed to AI generation tools. The methodology shapes the process; the deliverable is a production.
From the studio's first publicly shipped agent to the flagship knowledge system, each project is the same thesis applied to a different problem — knowledge, story, video, music, code, games, irrigation, generative art. Each has its own page, with the Explain → Synthesize → Verify breakdown for that project. The full catalog, grouped and cross-linked:
The model that produces content cannot evaluate its own output. Whisper verifies Kokoro. CLIP scores SDXL. Mistral judges llama3:8b. Python scores the spec the LLM just wrote. Trust separation at every verification boundary.
Every project starts with CONSTITUTION.md and ARCHITECTURE.md before a single line of code. The constraints are written down first. When the code needs to change, the doctrine changes first. The constraint document is the source of truth.
Not all failures are equal. Continuity failures are blocking — a story with inconsistent characters fails. Sound cue failures are non-blocking — a missing ambient bed degrades gracefully. Every gate is classified by whether its failure invalidates the artifact.
No unbounded loops. Every retry path has a maximum, and every maximum has a defined fallback — a neutral clip, a silence, a hard stop. Thrashing is a bug, not a strategy. The system fails predictably or not at all.
Every pipeline is proven with deterministic fakes — ScriptedLLM, ScriptedRenderer, scripted TTS — before any model weights download. The scaffold is the system. The models are one implementation of it. Tests run in seconds on zero dependencies.
Every tool emits the same NDJSON event vocabulary:
step_start / step_complete /
gate_pass / gate_fail / retry
/ done. Named stages, explicit data flow, observable
end-to-end — the Build It Publisher lineage in every project.
In my-AI-stro's audit loop, the summarizer produces better entries because the judge exists and it knows the criteria. In my-AI-script, the LLM produces more detailed specs because the rubric is in its system prompt. Knowing you will be scored changes what you produce.
Every project through Veritas ran on local models — Ollama, Kokoro, SDXL-turbo, MusicGen, faster-whisper, CLIP — on the founder's own hardware. That was never an ideology; it was economics. Free, private local models were how the scaffold got learned and proven without burning money proving it. Crypto Hunter AI broke the pattern on purpose: once real stakes were on the line — real crypto opportunities, real money, real scams trying to get past the gate — the frontier API spend (Claude Opus 4.8) was worth it. The same gate runs unchanged either way, because the scaffold was never trusting the model's tier in the first place — only its own verdict.
Depth on the flagships (my-AI-stro, The House Always Wins); the
cross-org debate layer for Opportunity (arguing priority across
engines, not truth — the genuinely novel piece of the recursion);
more Hunter-type engines on the shared hunter-engine
package (Grant/Scholarship next); the Journal of Informal Human
Protocols pilot; onboarding the wider StudioLabs and Productions
catalog (my-AI-scene, my-AI-beats, my-AI-story, my-AI-script,
my-AI-stro) into Entropy's own Collector — each only needs a declared
shape at its exit boundary, not a rewrite of what it already does.
The product identity this architecture was always pointing toward, now decided: a vending machine of disposable AI engineering — reusable primitives (the my-AI suite, the shapes, built once) dispensed as verified, one-time, disposable goods in throwaway containers — summoned, gated, run, and disposed of, with Veritas as the conductor holding the sequence, never the internals of any one engine. Three real instances already ship this way (Crypto Hunter, build-it, taichi-academy); generating a fresh container on request from a spec, not just packaging an existing project, is the next unbuilt increment. Simulation engineering — ecosystem, irrigation, combat AI, particle life — remains the specialty auditable AI keeps applying to new domains. Organized chaos, by trust.
A body of work substantial enough that the trajectory itself becomes the credential — not "look at this single project," but "look at the arc of shipping under one methodology," with Entropy OS as the name for that methodology once it stopped being infrastructure and became the thing being built.
Every MoreSalamander project is co-authored with AI — disclosed on each project, in the commit history, and as a matter of brand identity. The human role is constant across all of them: design the constraints, define acceptance criteria, judge outputs, decide what ships. The AI role is high-volume synthesis inside those constraints. Neither party does the other's job; both are visible in the result. The discipline traces back to early line-for-line sessions in a chat window, and carried forward as the tooling got better.