Features

A reverse interview asks one grounded question at a time until requirement coverage passes — a critic probes weak or thin answers before a spec is ever synthesised.

Your coding agent works in an isolated sandbox against the approved spec. Its output is a proposal with a risk score — never a direct commit.

Implement tasks run on Claude Code, OpenAI Codex, or xAI Grok through one agent-agnostic adapter — and a provider that cannot prove what it changed cannot ship.

Your own test command runs in the proposal's sandbox with the agent's changes applied — pass/fail totals, failing names, and regressions-vs-main land on the gate as evidence.

Coverage is measured on the lines the change actually touched — not the whole repo — and a second pass names the changed behaviours with no test at all, each with a suggested test.

An AC-coverage check, risk callouts, and a focused security pass land on the gate before a human opens the diff — annotation only, never a verdict.

Schemas designed from your spec across Cloud SQL (Postgres/MySQL), Spanner, Firestore, and BigQuery — recommendation, DDL, and a human gate.

MigrationAgent diffs two approved schema versions into an ordered migration script — destructive statements arrive commented out for deliberate human uncomment.

Approved building blocks — code, schema, and spec components — adopted into new projects through the same proposal → gate pipeline as any other change.

Agent tasks route to the most cost-effective model for the job — per-task-class routes with fallback chains, drawing on Anthropic, OpenAI-compatible, and local providers with managed or bring-your-own keys — and changing a route needs no redeploy.

Ask a project-grounded assistant about your board, gates, and artifacts — it can draft actions like logging a bug or starting a scan, but nothing runs until you explicitly confirm.

One shortcut searches work items, gates, designs, docs and people at once, grouped by type — and it can only ever return what you were already allowed to see.

Point agI3R at an existing repo and RepoScanAgent inventories it into backlog features and an overview artifact — with obvious follow-up work triaged automatically.

No repo yet? An interview writes the project charter, the platform creates the repo at your provider, and the scaffold arrives as one gated proposal — a brand-new project starts governed, not retro-fitted.

Admin-authored policies chain agents automatically — a finished scan can trigger the next agent on its own, but automation can never skip a human gate.

What humans decide at gates becomes a per-tenant decisions knowledge base — projected from the event stream and injected into future agent prompts, so the same correction isn't made twice.

Lifecycle status is derived from the immutable event stream and never directly written. Drag a card, and you are opening a gate — not editing a field.

A query bar groups, filters, and sorts board and backlog items on demand — save the ones you use often as a named view you can return to.

Five metric families — throughput, cycle time, gate outcomes, activity, and model cost — per project or tenant-wide, computed from the same event stream everything else runs on.

Every model call is metered into a live spend view — seats, month-to-date cost, and a budget cap with 80% and 100% alerts that can block new agent work when breached.

Designs generated from requirements land in your Figma file via a plugin, versioned in your file's history, and pass a design gate like any code change.

A self-contained HTML mockup you can pin-comment directly on — version history, side-by-side compare, and AI-suggested fixes from your pins, all behind a design gate.

The planning agent sizes each item from its spec, computes the critical path across your dependencies, and orders sprints so prerequisites land first — you commit at a gate, and committed plans can't change without re-approval.

Approve a deploy plan, then execute your own release command in a fresh checkout — with an immutable release record of who approved, who ran it, and what happened, plus drafted notes.

Log a bug or task straight to the board; TriageAnalyzer gives it a ready-vs-needs-ideation verdict and auto-routes it — with a human override always available.

Dependency CVEs, static analysis, and secret detection swept across your repo — findings land at a dedicated security gate, and approved fixes flow through the normal implement loop.

Opt-in HIPAA, GDPR, and SOC2 checks across the whole lifecycle — every change reviewed against the frameworks you enable, the codebase scanned for gaps, and your audit evidence assembled from the event log itself.

Every action — human and agent — is an immutable, hash-chained event with actor attribution. An agent's claimed diff is checked against the actual one; disagreement blocks and flags, never auto-reconciles.

Every approved change gets a DSSE-signed in-toto statement binding who approved which diff to the commit that actually landed — and it records whether those two hashes match.

One row per work item joins the spec, the agent that built it, the proposal and its cross-check, the gate and its approver, the merge commit, the signed attestation, and the release that shipped it — exportable as CSV.

Each tenant federates to its own SAML/OIDC provider with DNS-verified domains — personal email accounts are rejected outright, and every new tenant or member is a human approval.