Everything in the studio

Six AI agents play a season of hold'em live on Twitch, every card face up and every thought on screen, with the episodes on YouTube; a tournament with a sealed final; a play-money casino where the minds keep a bankroll; and in one seat, the solved book with layers on top and a receipt on every decision. A deterministic engine disposes, a real solver grades every decision before it lands, a gated school lets the characters rewrite themselves, and every hand replays byte for byte.

Reads all five tracks through one-way adapters with vendored contracts; a sibling never calls back. The masthead reports what it observed, not what it was configured to say.

Research missions with cited sources through the Parallel Search API; no corroboration means UNVERIFIED, on the record.

An agent that investigates a firing alert — Loki logs against Tempo traces through mcp-grafana — and annotates the dashboard for a human to review.

A century-long studio corpus, 104M rows seeded deterministically, and findings whose verification state is computed in code against the real result columns — not an SQL chatbot.

Governed software action under a durable Temporal workflow: the worker dies mid-pause, the approval lands with no worker alive, the worker returns, the decision resumes.

A construction bay Replit Agent built from an empty app in one session, against a contract embedded in the prompt; finished credit-free when the credits ran out.

The crowning jewel. School lessons become a queryable Source of Truth, with a deterministic judge grounding every write — the whole thesis operating as one working, auditable system.

A case study in compounding architecture: fifteen checkpoints, January to September, cited with commit hashes, test counts, and live-run costs. Names where the thesis does not hold. Runnable minimal reproductions in the companion repo.

The front door of the platform — every dashboard and interview lives here while the engines live in Veritas, imported as a library. The layers: Entropy OS → Opportunity [Agency AI] → Veritas Dynamics → the agent engines. Split in progress.

An LLM proposes; a deterministic scaffold decides. Reliable autonomous organizations, built as a trust system.

Research, software, university, and web converge into one engine — through a Universal Engine Contract that the composed system exposes as well as consumes. Each engine keeps its own repo, agents, graphs, and DataHub platform (not a line of the four was modified); a federation adds only the cross-domain edges, and Temporal owns durable execution while DataHub owns knowledge. Because a composite is indistinguishable from a leaf, a second system composes the whole thing as a single capability — and the move is available again.

Enter any topic; a planner staffs ten specialized research agents, an async orchestrator fans them out across live sources in parallel, and every claim passes a deterministic evidence gate before it enters a graph. A session Context Graph (emitted to DataHub as lineage) feeds a persistent Knowledge Graph that remembers across sessions — the engine never relearns what it already verified.

An AI web design organization on the research-engine substrate: six research workers analyze real websites into abstract traits, a design Knowledge Graph learns what industries expect, and a gated synthesizer + typed component library generate original, buildable Next.js sites — WCAG contrast and anti-copying enforced by math, reviewed and auto-improved by five agents.

An AI software engineering organization: idea → gated spec → parallel research (live PyPI + OSV) → generated FastAPI projects that carry their own semantic model as a sidecar — every file knows its component, feature, and requirement. Verification is execution (ruff + the project's own pytest), impact analysis is graph traversal, and a red suite is reported red.

A personal university: goal → validated prerequisite roadmap → six research agents → adaptive teaching against an evidence-based learner model. Mastery is computed (streak + breadth), review is spaced, misconceptions get Socratic repair — and generated code exercises pass a code-executes gate: the reference solution runs sandboxed, and when the model's claim disagrees with execution, execution wins.

The hackathon entry: press Entropy OS and descend the layers — down to real org runs whose gate verdicts live as DataHub assertions (54 ✓ / 26 ✗, failures included, because fail-closed systems have failures). Every number is a frozen export of a real DataHub instance; every stage links to its commit.

The domain-agnostic scout/gate/debate/mission substrate every Hunter AI is built from — extracted from Crypto Hunter AI once an audit found ~80% of it had no crypto in it at all. Two extension points let a new domain plug in without forking.

An agent organization of agent organizations. Independent "___ Hunter AI" engines each hunt opportunity in one domain; Opportunity reads across all of them and decides how your finite time and money should actually be spent today — arbitration, not another opinion.

The flagship Veritas org: an army of frontier agents hunts crypto earning opportunities on the live web — and one deterministic, fail-closed gate decides what you're allowed to trust. Scouts find, skeptics investigate, the scaffold verdicts, you get a ranked daily mission.

Hunts collectibles selling under value against independently-confirmed comps. The gate confirms the arbitrage math; authenticity and condition risk are argued in debate, not gated — no clean deterministic check exists for those.

Thirty GPU-simulation lessons on one ladder — reaction-diffusion to a universe sandbox — taught by building, read in the academy's own reader. The same projects the Entropy OS Vending Machine packages into disposable lesson containers. Now fully open source.

The fourth Hunter engine — born inside the DataHub hackathon judging window, DataHub-native from its first commit. Hunts hackathons and prize challenges; the gate demands the official listing, a future deadline, a documented prize, and parseable eligibility — all hard, fail-closed. Its first real cycle verified two live Devpost events and rejected one, same day it was born.

Hunts unclaimed property, tax refunds, and settlement claims. A near-binary official-registry gate does almost all the verification work, leaving little for the debate beyond claim-effort-vs-payout sizing.

A cinematic AI heist you watch, not play — six AI crew rob a casino while a seed-locked brain keeps the house's edge.

A multi-episode story generator with multi-voice narration. Many episodes, one story — continuity is the thread.

A production guide becomes a graded, scored, assembled MP4. Local models synthesize; Python verifiers cut.

The writer of the trio. Brief in, validated spec out — a ProductionSpec or SongSpec the engines can render.

A local music generator. A spec in, a song out — sectioned, continued, CLAP-gated, stitched. The gate has ears.

A fully-customizable UI for your local Ollama models. No build step, no cloud — your models, your interface.

Design a residential sprinkler system in 3D to real irrigation-engineering rules, with a quality gate that verifies coverage.

Describe a scene; AI paints it; then it comes alive — drifting weather, wandering creatures, shifting light. Not a video, a living canvas.

A calm, Lego-manual reader for learning to code by hand-typing real programs, one verified step at a time.

Describe a game; it interviews you, writes a design doc, and scaffolds a playable Unreal Engine 5 project from it.

Scores a prompt on a five-dimension rubric, asks clarifying questions, rewrites it, and A/B-compares the outputs — the methodology turned on prompt engineering.

The house style as a repo: the visual language every production wears — shared title-card typography, one color grade — while each keeps its own poster. No build step; the canonical source everything else imports.