An autonomous organization that refuses to lie about what it built.

The thesis. Reliability is not a property of the model — it's an architecture built around the model. An LLM is a proposal engine. Trust comes from a deterministic scaffold — typed artifacts, machine-checkable gates, provenance, institutional memory — that decides what to accept. Swap the model freely; the floor doesn't move.

So Veritas isn't trying to win the crowded race to "agents that write code." Its lane is the how: treating an autonomous organization as something that remembers, validates, governs, and refuses — the boring substrate everyone else has to come back and build once the demos stop being trustworthy.

Part 2 — How it works

The entire engine is built from just two ideas.

① The Artifact — typed, owned, provenance-stamped

Nothing floats around as a loose string. Every piece of work is an Artifact that carries who made it, why, and the verdict of every gate that has judged it. That trail is what makes a "yes" explainable instead of a vibe.

② The Gate — the only thing allowed to say yes or no

A gate is a pure function Artifact → pass | fail. It must declare its honesty level: HARD (a real deterministic check) or SOFT (advisory — a heuristic or an LLM judge that can flag but never block). This rule is the heart of the codebase:

# engine/gate.py — the decision engine
class Gate(ABC):
    name: str
    determinism: Determinism      # HARD or SOFT — declared, never guessed

    def check(self, artifact: Artifact) -> GateResult:
        """Return a pass/fail verdict PLUS the evidence for it —
        never a bare boolean. Evidence is what makes the decision explainable."""
        ...

That invariant lives in one place, the ValidationGate — the final authority every run passes through. It judges nothing about the domain; it only reads the provenance and confirms the floor was cleared:

# engine/validation.py — the org-agnostic final authority
def check(self, artifact):
    prior = artifact.provenance.gate_results
    hard  = [r for r in prior if r.determinism is Determinism.HARD]

    if not hard:                      # nothing was actually proven
        return withheld("no hard verification to validate")
    if any(not r.passed for r in hard):  # a real check failed
        return withheld("hard gate(s) failed")

    return approved(f"approved — {len(hard)} hard check(s) passed")

The loop: Explain → Synthesize → Verify → Persist

A run is a deterministic state machine over artifacts. Agents only fill the proposal slots; the gates own every transition. When a hard gate rejects, the implementation is re-proposed with the failing gate's evidence injected — so the next attempt is actually informed, not a random retry.

Memory that actually changes behavior

A rejection isn't just logged — it's retrieved at the start of the next similar task and prepended to the proposer's prompt. The proof that this matters is a single test the whole project is anchored on: an org fails a task uninformed, the failure is remembered, and the next run — warned by recall — succeeds. That's behavioral learning, deterministically demonstrated.

Part 3 — The honest part

Not everything can be machine-proven. The discipline is to be honest about it. Every artifact is tagged with who verified it — and the UI never shows something as more verified than it is.

And, sitting honestly beneath all three, a Chat tab: a plain model with no gates, no grounding, no memory — the model's word alone, labelled exactly that. It's not a tier so much as the absence of one, and it earns its place by making the others visible: it is precisely what every studio above would be without the scaffold. Tier zero, named for what it is.

Part 4 — Why one engine, many studios

The load-bearing rule of the whole project: what makes two studios different isn't the artifact they produce — it's how they know it's true. Same way to verify → same org, different role. Different way to verify → a genuinely different org. On one unchanged engine, five distinct verification models run side by side:

Studio	Makes	How it knows it's true
software	code	execute it — run the cases & properties in a sandbox
web	web pages	render it — a real headless browser asserts the DOM
research	grounded reports	ground it — every claim traces to a pinned source, verbatim
production	narrated videos	referential integrity — entities stay consistent through the whole chain
empirical	hypotheses	reproduce it — re-run the experiment, results must match

Because verification is the only thing that differs, products can reuse a model (a Newsroom is just the research grounding pipeline) or compose several (a Startup = web landing page + software MVP). Adding a new studio is one registry entry — never an engine rewrite.

One layer up from composition, a Plan tab turns the interview loose across all the studios. Describe something bigger than one engine — "a researched landing page for a coffee startup" — and a planner proposes an ordered plan (research → web → …); a deterministic gate checks it's runnable (real studios, concrete goals) before anything runs; you confirm; then each step ships through its own gates. The plan ships iff every step ships. The presets stop being hardcoded recipes and become plans it derives in conversation. And the handoff obeys the same rule as everything else: where one step's verified output can be checked by the next — a grounded report feeding a later grounded step — the trust chains; where no downstream gate could verify it, that handoff stays the human's call rather than a silent unchecked bridge.

The verification is real enough to catch the model when it's wrong. A favorite example: when proving a property like "decoding reverses encoding," the system uses an injection-safe vocabulary of oracle-free relations rather than trusting a number the model wrote down:

# the model never supplies the "expected" answer — the RELATION is the oracle
round_trip(encode, decode)     # decode(encode(x)) == x  for all x
involution(reverse)            # reverse(reverse(x)) == x
idempotent(clamp)              # clamp(clamp(x)) == clamp(x)
monotonic(double)              # x < y  ⇒  f(x) < f(y)

# a correct implementation PASSES these; a subtly wrong one is caught —
# without ever asking the model "is this right?"

Part 5 — The receipt

The same builds were run across cheap local models and frontier cloud models, through the identical gates. The result is the thesis in data: where a task is achievable, a small free model — kept honest by the scaffold — reaches the same verified bar as an expensive one. Where it isn't, nothing ships a false green. The gates are the equalizer, and the floor.

A second reading from the same bench sharpened the local story. Taking one model and flipping only its reasoning on or off, thinking turned out to be the difference between shipping and not at module scale — converting a build that never passed into a first-try success — while on easy functions it was simply ~10× slower for no gain. So thinking is now adaptive: on for the hard shapes, off for the easy ones, and capped to fewer retries when it's on (a careful answer that fails twice rarely flips on a third). The gates are what make this safe to tune at all — every thinking build that ships still clears the same hard floor, so it's a genuinely verified pass, never a reasoning-induced false green.

Part 6 — The strange loop

The capstone milestone is met: the Software Studio was pointed at the goal "estimate the number of LLM tokens in a string" — a real, needed component of Veritas. It shipped estimate_tokens(), accepted only after clearing its own hard gates. No human judged the code; the gates did. That function now measures Veritas's own runs in the hub.

The trust invariant held under self-reference: even when extending itself, the system accepted the work only on hard proof — never on the model's word. Splicing it into the live system stays a deliberate human step, by design.

Part 7 — Where it's going

The architecture is proven end-to-end. The road ahead is about reach and rigor, not reinvention: