The agents

Runs the reverse interview — one grounded question at a time, informed by your brief, your repo, and your component library.

Produces: A requirements conversation deep enough to write a spec from.

Gate: Feeds the requirements gate — a human approves the spec it leads to.

A deterministic coverage rubric, not an LLM — blocks synthesis until answers reach the depth bar, or a human explicitly overrides it.

Produces: A pass/fail coverage verdict per requirement area, with any override logged as its own event.

Gate: Requirements gate — the rubric decides when interviewing is done; a human still approves what comes out of it.

Turns a completed interview into a four-part requirements artifact in one pass, with a quality check and a single repair attempt if it falls short.

Produces: The requirements artifact a human reviews and approves at the requirements gate.

Gate: Requirements gate — nothing downstream starts until a human signs off on the artifact.

Surfaces follow-up questions and adjacent ideas mid-interview, without slowing down the main thread.

Produces: Breakout ideas you can park straight to the Backlog instead of letting them creep into the current spec.

Gate: No gate of its own — its suggestions are optional and always human-reviewed before becoming a work item.

Splits an approved requirements artifact into build-ordered implementation tasks, flagging anything that reads like a separate idea.

Produces: A task breakdown ready to hand to the coding agent, plus any breakout ideas it noticed.

Gate: Decomposition approval — a human signs off on the split before implementation starts.

Writes code in an isolated sandbox against the approved spec — Claude Code, OpenAI Codex, or xAI Grok, behind one agent-agnostic adapter with fail-closed provenance.

Produces: A proposal: the diff, a risk score, and a claimed summary of what changed.

Gate: Proposal gate — cross-checked against the actual diff before a human decides; disagreement blocks and flags, never auto-reconciles.

Reviews a proposal's diff the moment it's created — checks acceptance-criteria coverage and calls out risks — and skips silently rather than guess.

Produces: An AC-coverage verdict, risk callouts, and a summary attached to the proposal gate.

Gate: Proposal gate — annotates only; it never approves or blocks, the human still decides.

A focused security pass — secrets, injection, authz, data exposure — run only on proposals with high or critical blast radius.

Produces: A verdict and findings attached to the gate; malformed output shows as "pending", never a fabricated pass.

Gate: Proposal gate — an advisory annotation, not a decision.

A per-change compliance pass — checks a proposal against the frameworks a tenant enables (HIPAA, GDPR, SOC2) and cites the specific control each finding touches.

Produces: Control-cited findings on the gate; malformed output shows as "pending", never a fabricated clean, and a fabricated control citation is dropped rather than trusted.

Gate: Proposal gate — advisory by default; an opt-in hard-gate lets a high/critical finding raise the gate to require a compliance approver, but a human still decides.

A system executor, not an LLM — runs your own test command in the proposal’s sandbox with the agent’s changes applied.

Produces: Pass/fail totals, failing test names, and regressions-vs-main attached to the proposal gate as evidence.

Gate: Proposal gate — evidence only; it never blocks, the human decides.

Turns an approved requirements artifact into Figma design operations, applied to your file through the Figma plugin.

Produces: A generated design in your Figma file, versioned where the file supports it, behind a design gate.

Gate: Design gate — a human approves the design before it counts as settled.

Designs a schema from your spec across whichever datastore you target, composing in any adopted schema components.

Produces: A schema recommendation and generated DDL for a human to approve or send back for revision.

Gate: DB-design gate — approval snapshots the version so later migrations have something to diff against.

Deterministic, not an LLM — runs your coverage command in the proposal's sandbox and intersects the report with the lines the diff actually changed.

Produces: Percent of changed lines covered, plus the uncovered lines by name, attached to the gate as evidence.

Gate: Proposal gate — below your threshold it raises the required approver rather than blocking; a human still decides.

Reads the diff for changed behaviours that no test covers, grounded on the uncovered lines when coverage ran, and repo-rooted when it did not.

Produces: A named gap per untested behaviour with a suggested test — text on the gate, never a file in your repo.

Gate: Proposal gate — advisory annotation only; it never writes a test, escalates, or decides.

Not an LLM — a pure diff between two approved schema versions, planning the ordered ALTER/CREATE/DROP statements between them.

Produces: An ordered migration script, with destructive statements arriving commented out for deliberate human uncomment.

Gate: Migration gate — nothing runs until a human reviews it and chooses what to uncomment.

A project-level vulnerability sweep — dependency CVEs, static analysis, and secret detection via real tools, plus an LLM triage pass.

Produces: A normalized, deduplicated, severity-ranked findings report for the project.

Gate: A dedicated security gate; approved findings become a remediation proposal through the normal implement loop.

A whole-codebase compliance readiness sweep against HIPAA and GDPR code-checkable controls — encryption at rest, access logging, an erasure path, no PII in logs.

Produces: A per-control pass / gap / unknown report; an uncertain result is "unknown", never a fabricated pass.

Gate: Report only — a human turns any gap into a remediation work item; nothing is filed automatically.

Gives manually logged bugs and tasks a ready-vs-needs-ideation verdict, so obvious work skips a needless interview.

Produces: An auto-routed work item — straight to Ready, or into a seeded quick interview.

Gate: No gate of its own — a human can override the routing from the board at any time.

Drafts the deployment plan for a release — steps, checks, and rollback — from the work approved since the last one.

Produces: A deploy plan a human reviews before anything runs.

Gate: Deploy gate — approval is required before the release command executes.

Not an LLM — a system executor that runs the human-approved release command and records exactly what happened.

Produces: An immutable release record: who approved it, who ran it, the command, and its output.

Gate: Deploy gate — re-verified immediately before running, so a stale approval can never execute.

Drafts a headline, highlights, and notes onto the release record after a release succeeds, from its acceptance criteria and merged proposals.

Produces: Release notes on an already-approved release — best-effort, and a failure here never touches the release itself.

Gate: No gate of its own — it only ever writes the notes fields on a release a human already approved.

Sizes each work item from its spec, computes the dependency critical path, and packs sprints so prerequisites land first — explaining its reasoning in plain language.

Produces: A sprint plan — sizes, dependency-ordered sprints, critical path with slack, and rationale — for a human to commit to.

Gate: Plan gate — a committed plan can’t change without going back through approval.

Inventories an existing repository into board-ready features, the first time a project is onboarded.

Produces: A backlog of discovered features plus an overview artifact of the stack.

Gate: Backlog publish — a human reviews the inventory before it becomes live board items.

Deterministic rules, not an LLM — sweeps model-usage rollups every six hours and proposes cheaper routes where quality allows.

Produces: Route-downgrade recommendations with estimated monthly savings, surfaced on the admin Platform tab.

Gate: A human applies the change by writing the route — the governor never writes one itself.

Not an LLM — maps the immutable event log to SOC2 controls (change management, access, monitoring) and freezes each audit period into a tamper-evident, write-once snapshot.

Produces: An auditor-ready evidence view and CSV/JSON export per period — coverage-honest, marking anything it cannot attest as "manual evidence required" rather than claiming it.

Gate: No gate — a read-only projection of governance that already happened; the trail is the evidence.