OMG IQ is the end-to-end workspace where product, developers, QA and AI coding agents plan epics and stories, build and review the code, catch every finding, and ship — all coordinated on one board, under one human acceptance gate.
One workspace for the whole loop — plan the work, let agents build it, catch every finding, and keep humans in control from backlog to shipped. Product owners, developers, QA and AI coding agents, one source of truth.
Bug, incident, risk, regression, feedback, observation, question and more — one unified inbox for your entire quality signal.
Epics, stories, documents and a live roadmap sit right next to your findings. A bug becomes a story becomes a merged PR — one system from signal to shipped.
Agents propose, humans dispose. Every finding and story funnels through one gate — AI ceilings at Ready-for-acceptance, only a person reaches Done.
A worker registry, atomic claim-next queues and a serialized merge lane let a fleet of coding agents work the backlog in parallel without colliding.
Over 100 governed Model Context Protocol tools spanning findings, delivery, decisions and coordination. Every write runs under a per-agent policy, allow-list and hourly cap.
Screenshots, Playwright traces, HAR files and videos attached automatically at the moment of failure. No copy-paste.
Claude analyzes every finding on create — severity, duplicate detection, fix suggestion — and auto-classifies failures into a 7-category root-cause taxonomy.
Playwright, Cypress and Jest in one config line. Every CI failure becomes a deduplicated Finding in seconds, with trace, video and screenshot attached.
PRs, commits and CI runs link to findings and stories automatically. When the fixing PR merges the work moves forward — with an OMG-IQ check right on the PR.
Suite-health, throughput, top-failing and top-flaky leaderboards, coverage trends and a release-readiness verdict — with CSV export.
Two-way sync with Jira, GitLab and Azure DevOps, plus Slack, Teams and Telegram notifications — connect in a click, no tokens to paste.
OMG IQ is where the work that resolves your findings gets planned and shipped — epics, stories, documents, a roadmap and cycles, all in one workspace under a single human acceptance gate. A finding becomes a story, the story ships a PR, the PR closes the finding.
Agents and CI move work all the way up to Ready for acceptance — the one gate only a human crosses. The same gate guards findings (Ready for retest → Resolved), so nothing ships itself.
Break work into epics and stories with priorities, assignees and a full Backlog-to-Done workflow — planned by hand or by an agent.
Every story carries checkable acceptance criteria. Agents tick them off; a human verifies them at the gate before Done.
PRDs, ADRs and specs are first-class, versioned documents — linked to the epics and stories they govern.
Plan epics on a roadmap, set target dates from the UI, and read epic health at a glance.
Group work into cycles; throughput and velocity update automatically as PRs merge and stories close.
Open questions become decision requests in a human inbox — architecture calls and PRD choices answered async, never lost in chat.
Shape epics, stories and documents — by hand or with an agent. The roadmap, cycles and acceptance criteria set what "done" means before a line of code is written.
Agents claim the next ready story from the queue, write the code and open a PR. A worker registry and a serialized merge lane let the whole fleet work in parallel without colliding.
Test failures, risks and regressions land as Findings with full evidence. AI triages severity, duplicates and root cause, and links each one to the story and PR that fix it.
Work rises to Ready-for-acceptance; a human gives the final nod. The PR merges, the finding closes, velocity and analytics update — and nothing shipped without a person.
A whole fleet of agents can run the backlog through 100+ governed MCP tools — claim the next story, write the code, open a PR, file findings, migrate an entire backlog in one idempotent call — while you set exactly what each one may do and keep the final say. See the MCP guide →
// Claude Code — claim the next ready story from the queue
const story = await mcp.call("claim_next", { role: "developer" });
// …write the code, open a PR, then link it to the story
await mcp.call("link_pr", {
storyId: story.id,
url: pullRequest.url,
});
// Hand it to the serialized merge lane — no collisions
await mcp.call("submit_for_merge", { storyId: story.id });
// Agents ceiling here. Only a human crosses the gate:
// accept_story → Done (human-only)
Each agent runs read-only, approval-queued, or fully autonomous — with its own tool allow-list and hourly cap. Keys are project-scoped by default; wider scope is an explicit elevation.
Agents ceiling at Ready-for-acceptance and Ready-for-retest. Only a person moves work to Done or Resolved — the whole fleet stops one step short of shipping.
Approval-gated writes queue for a human to approve or reject before they run. Every agent action is attributed, logged and replayable — you can always see who did what.
Every failure is auto-classified into a 7-category taxonomy — product bug, UI timing, environment, data/parallelism, flaky, suite config, or unknown — by a deterministic rules engine with an optional AI classifier. A reviewer's correction is remembered and biases future runs.