An LLM proposes. A deterministic scaffold decides.
Reliable autonomous organizations. The model is a proposal engine;
trust comes from the scaffold around it — typed artifacts, machine-checkable gates,
provenance, institutional memory. It's a trust system, not a cleverer agent.
Reliability is an architecture, not a bigger model.
Almost every "AI builds software" project bets on capability — more model, more agents,
and reliability is supposed to emerge. Veritas makes the opposite bet:
The model is swappable; the floor doesn't move. An LLM only ever guesses.
A guess becomes an accepted artifact only by clearing a deterministic gate that can prove it —
and a rejected guess is remembered, so the organization learns from what it refused.
The whole machine in one picture: propose → prove → ship or remember.
How it works
Two primitives, one loop, one invariant.
Everything is built from two primitives: a typed artifact (what an agent produces) and a
gate (a check that declares itself HARD or SOFT). One loop runs them — a proposer makes an
artifact, the gates rule on it, and it is accepted only if it earns it. Every accepted artifact
carries a full provenance trail: who proposed it, which gates passed, what it was informed by.
The invariant: zero hard gates can never accept. Only a hard gate can say yes; soft
gates — including LLM judges — can flag, but never block, and never on their own ship anything. So the
system can never present a guess as a proof. And a rejected artifact isn't thrown away: it's written to
failure memory, so the refusal can teach the next attempt.
Watch a run
A proposal earns acceptance — or is refused and remembered.
software org · build(reverse_string)attempt 1
propose
→
syntax
hard ●
→
security
hard ●
→
property
hard ●
→
validation
hard ●
→
accepted
Accept iff every hard gate passed — nothing ships on a soft gate alone. A rejection is written to failure memory and fed back to the next attempt (the retry loop).
It learns
An organization that remembers what it refused.
Memory only counts if it changes behavior. When a task starts, Veritas recalls the relevant past
failures and decisions and feeds them to the proposer before it proposes — so it doesn't walk
back into a mistake it already made. And when a gate rejects an artifact, the proposer re-attempts while
seeing the gate's evidence ("misquote of src1: …"), self-correcting
against the exact reason it failed. Getting better here isn't a bigger model; it's a loop that compounds
what the gates taught it.
What counts as an organization
An org is defined by its verification model.
Not "it makes a different artifact" — ask what verifies it. Same verification model means
same org, different role; a genuinely different way of knowing an artifact is true means a different org.
Five distinct verification models run side by side on one unchanged engine:
Org
Makes
How it's verified
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 chain
empirical
hypotheses
reproduce it — re-run the experiment, the results must match
Products that reuse or compose these models — Newsroom, Education, Startup, Game — are
presets, not new orgs: the substrate generalizes without new verification machinery.
The cast
Every agent proposes; not one of them decides.
More than twenty specialist agents do the work across the orgs. They are all proposers — they
make artifacts; the gates rule. Some are pure tool roles with no model at all. And
the checkers are kept honest by separation: the QA agent writes its tests without ever seeing the code, and
the research judge runs on a different model than the writer.
software — 9
Router — picks the function / module / app pipeline (a soft pre-decision; still hard-gated)
Spec Agent — an executable spec from a goal: name, signature, cases, oracle-free properties
Developer Agent — the source code; rewrites on rejection seeing the failing gates' evidence
QA Agent — independent edge-case tests, written from the spec without ever seeing the code
Doc Agent — docs whose code examples are run against the real function
Architect Agent — a module contract: which functions exist, their signatures and properties
PM Agent — acceptance as executable tests; at app scale, designs main()'s contract
Planner Agent — a plan of module briefs for a goal too big for one module
Integrator Agent — the entrypoint main() that composes the modules end to end
web — 2
Designer — the page's verifiable contract: the elements it must contain, as selectors (not its looks)
Web Developer — a single self-contained HTML document; re-writes seeing the failing render gates
research — 1 + judge
Researcher — a report whose every claim cites a source and quotes it verbatim; re-writes on a misquote
production — 6
Concept Developer — the concept and its declared entities — the contract everything downstream is held to
Scriptwriter — scenes and beats, using only the concept's declared entities
Storyboard Artist — shots that cover every beat and show only the entities present in it
Asset Generatortool — an image per shot, narration audio per beat, each entity at its pinned reference
Editortool — shots in storyboard order, each given its beat's narration time: a contiguous timeline
Publishertool — renders the timeline to a real file with ffmpeg, to the target platform profile
empirical — 3
Scientist — one falsifiable hypothesis with a machine-checkable prediction (a comparison or threshold)
Experimentalist — a self-contained, deterministic experiment that measures the metric
Experiment Runnertool — runs the security-scanned experiment repeatedly, records each result
cross-cutting
Interviewer — in create mode, asks until vague intent becomes a checkable spec — manufacturing the gate
Judge — a separate-model fact-checker behind soft gates: it can flag, never block
Trust tiers
Never show something as more verified than it is.
Not everything can be machine-proven. The discipline is to be honest about which tier each
artifact earned, and never to dress one as another.
● machine-proven
A hard gate proved it
Executed, rendered, grounded, reproduced. A fact, not an opinion — the only "done" that ships.
○ model-judged
An LLM judged it
An advisory opinion (e.g. "does the source support the claim?"). Can flag, never block.
◆ human-approved
A person signed off
For taste — where feel is the only valid oracle. Real verification, human-tier, learned as memory.
◆ human-vouched
A person curated the source
The Knowledge Graph: you vouched the source is worth keeping — not that its claims are true.
The Knowledge Graph
A knowledge commons that can't be laundered into fact.
Any org can draw on a shared store of curated material — paste a URL, the transcript is fetched and
kept. But curated is not verified: a human vouches for the source, not for the truth of what it
says. So a vouched source can ground an attributed claim — "Source X states Y" — and is
refused the moment it's used to assert "Y is true." The containment is a hard
gate that's checked, not trusted — the same discipline, applied to knowledge coming in.
It's measured
New verification earns its place on data, not intuition.
A benchmark harness runs the same goals across cheap local models and frontier cloud models and records
what actually clears the gates. The headline finding: where the work is achievable, a cheap local
model matches a frontier model on accepted-rate — because reliability lives in the
scaffold, not the model — and where it isn't, every model is honestly refused
rather than passed by a hopeful guess. No false greens, ever. The thesis, in data.
What it's already done
Past a single task — toward a platform that ships.
Built a piece of itself
The strange loop: the Software Studio was given the goal "estimate the tokens in a string"
and produced a real Veritas component — accepted only after clearing its own hard gates. No human judged
the code; the gates did.
Plans across orgs
A goal bigger than one studio becomes an ordered plan across the engines — and the plan ships only if
every step ships. The all-or-nothing discipline, one level up.
Create mode
For work where taste is the only oracle: an interview asks until vague intent becomes a checkable
spec — manufacturing the gate up front — then a human approves the result, captured as a profile that
learns your taste.
Where it stands
✓ built the engine substrate — Artifact · Gate · Memory · Run · Executor · Validation