Steriod is AI-assisted, not AI-trusted. Agents do the laborious work — reading documents, drafting rules, planning analyses — and every consequential action passes through a human gate. That division of labour is architectural, not a policy setting.
A requirement becomes part of your verification baseline only when a named human reviews and approves it in the UI. No agent — not ours, not one you connect over MCP — has an approve capability. The tool simply does not exist on the agent surface, so it cannot be prompted, jailbroken, or misconfigured into existence.
Agents produce drafts and proposals. The state change to "approved" is a separate, human-initiated action recording who signed and when.
When the Vi assistant wants to modify anything, the change is shown to you for confirmation before it's applied.
Agent conversations and worker runs are durable records with full event logs — you can audit what an agent did and why, after the fact.
Vi lives inside the Steriod UI with full project context: your requirements, runs, signals, and imported documents. Conversations are durable — reload the app mid-investigation and continue where you left off.
"Which requirements failed in last night's run?" — answered from the live project, with links to the runs and rules it cites.
Point Vi at an imported specification and it proposes Axiom rules per requirement — each explained in plain English for review.
Large jobs — importing a 200-page spec, drafting rules for a whole document — are delegated to background workers so the conversation stays responsive.
Configure the LLM providers you trust — local, on-network models, a European cloud, or hosted APIs — per task, from the app's settings.
A local model on your own hardware, a European cloud, or a hosted API: several providers side by side, chosen per task. Detection, evaluation and recording need no model at all.
Document imports and bulk rule drafting run as background agents with their own lifecycle: they survive restarts, can be cancelled, resume where they stopped, and keep a full log you can inspect from the project Library.
Ingests a specification PDF batch by batch — resumable on failure, with the uploaded source and a complete import log kept with the project.
Walks a document's requirements and produces draft rules for each — queued for human review, never auto-approved.
Turns a plain-language question into a versioned workflow run: bounded planning steps with verified contracts, deterministic execution — the LLM plans and narrates, the engine computes.
Everything agents produce — analysis results, drafted documents, import manifests, full run audits — lands durably with the project. Humans browse it from the Library page; fresh agent sessions are seeded from it, so context survives across conversations instead of living in one chat's history.
The platform's tool layer is exposed as a Model Context Protocol server. Connect Claude or any MCP-capable agent and it can list projects, search requirements, inspect signals and runs, validate rules, and run analyses — under exactly the same constraint as our own agents: no approve tool.
> which requirements in "TTC" are still failing?
tool search_requirements → 3 results
tool get_pipeline_results → TTC-T-4 fail · TTC-T-9 not_exercised
> draft a fix for TTC-T-4 and validate it
tool validate_requirement → compiles, 0 warnings
-- draft saved for review. approval: a human, in the UI.Send us a specification; on the call we walk through its coverage, the drafted rules and the approval loop.