What you review
Invariants, golden fixtures, and provenance trails — not generated rule code or orchestration graphs.
Studio Track
How you build and trust
an AI agent system.
The Studio Track is the default path through JacqOS. You don't review AI-generated code line by line. You review invariants, verify scenarios, trace decisions, and replay deterministically. Four activities. Full confidence.
The default path
Verify behavior, not implementation.
Traditional code review doesn't scale when AI writes the logic. The Studio Track replaces line-by-line review with four verification activities that give you bounded, inspectable guarantees in less time — like BDD for the AI era.
What the platform checks
For the fixed evaluator and recorded lineage, every admitted transition satisfies your constraints. Every fact traces to evidence. Every fixture scenario replays identically.
What you ship
An agent system with explicit safety boundaries, executable fixture evidence, and full audit provenance.
Four activities
Review rules. Verify scenarios.
Trace decisions. Replay everything.
Each activity builds on the last. Together they form a complete verification workflow — from declaring what must be true, to checking it against every scenario you define.
01
Review business rules
Invariants as the safety boundary
You declare what must always be true: "a patient cannot be double-booked," "transfers over $10k require two approvals," "no prescription without a verified diagnosis." These invariants are your safety boundary. The engine checks every proposed state transition against them and blocks anything that violates a constraint — before execution, not after.
You review: short, declarative invariant rules.
You skip: the generated logic that derives state.
02
Review scenario evidence
Golden fixtures as executable contracts
Golden fixtures are deterministic input timelines with expected outcomes. Each fixture is a complete scenario: a sequence of observations, the facts that should be derived, and the intents that should fire. Run them and get a binary pass/fail with a cryptographic digest. They're not flaky integration tests — they're digest-backed evidence that this evaluator matches every scenario you define.
You review: scenario inputs and expected outcomes.
You skip: how the engine derives the result.
03
Trace decisions in Studio
Visual provenance as the zero-code debugger
When something looks wrong, open Studio and follow the provenance chain backward. Every derived fact links to the specific observations that produced it through explicit edges. Click an unexpected intent and trace it back through facts, atoms, and observations to the exact evidence that caused it. No logs to grep. No state to reconstruct. No generated code to read.
You review: a visual graph from outcome to cause.
You skip: scattered logs and guesswork.
04
Replay and verify
Deterministic replay from recorded observations
The observation log is the canonical source of truth. Replay any session from recorded observations and get identical derived state every time. Change a rule, replay the same observations, and diff the results. This is how you iterate safely: make a change, replay, verify, ship. No "it works on my machine." No environment-dependent behavior. Just deterministic, reproducible evaluation.
You review: diffs between replay runs.
You skip: manual regression testing.
The workflow
A feedback loop, not a checklist.
The Studio Track isn't a one-time gate. It's a continuous loop you run every time you change rules, add scenarios, or investigate an unexpected outcome.
1
Declare invariants
Write the constraints your system must always satisfy.
→
2
Define fixtures
Create scenarios with expected inputs and outcomes.
→
3
Replay & verify
Run fixtures. Check invariants. Inspect provenance.
→
4
Ship with evidence
Export the evaluation package with full audit trail.
What you skip
The Studio Track replaces work
that doesn't scale.
No line-by-line code review
AI writes the derivation rules. You review the invariants and fixtures that constrain the rules' behavior. The platform checks the resulting model against your constraints.
No log archaeology
Every decision has a provenance chain. Click an outcome and trace it backward through the graph. No scattered logs, no reconstructing state from timestamps.
No flaky test suites
Golden fixtures are deterministic by construction. Same observations, same evaluator, same result. Every time. Failures are real, not environmental noise.
No manual regression testing
Change a rule and replay every fixture in seconds. The platform tells you exactly which scenarios changed and why. Sub-250ms hot-reload keeps the loop fast.
Ready to build your first
verified agent app?
The quickstart walks you through invariants, fixtures, provenance, and replay — all in one working example.