Six stages. Two human sign-offs. 152 specialist agents in between. This is the whole picture: how a single ServiceNow story flows through the GeneWorks delivery loop, and — just as importantly — an honest map of what the agents build end-to-end and what they won't touch.
Every story — a catalog tweak, a business rule edit, a scoped app feature — runs through the same six stages: Requirement, Design, Task Planner, Execute, SN Deploy, Verify. The agents drive all of them. At two points, the loop pauses for a human: design sign-off before anything is built, and verification sign-off before it ships.
You talk to the Requirement agent. It turns whatever you bring — a Jira story, a CSV from a workshop, a Visio swim-lane, or plain English — into a structured, versioned Functional Requirements Spec, and asks clarifying questions where the requirement is thin. Too ambiguous to specify? It bounces back with a structured list of what's missing.
The Design agent produces a full Solution Design — data model, dependencies, ACL implications, integration shape, and the exact ServiceNow Fluent artifacts to build. It reads from the workspace's accumulated context, so it matches your team's conventions. Then your architect reviews and signs off — nothing builds until this happens.
The Planner agent breaks the approved design into a granular, ordered implementation plan — every table, role, group, system property, ACL, business rule, and test as its own task. You can regenerate or adjust the plan before a single line is built.
The Main agent builds the tasks in parallel waves, writing real ServiceNow Fluent code (React + TypeScript) you can read in the built-in IDE. ATF and functional tests are authored alongside the build — not after the fact. Each task is marked done or flagged, and every agent sees the others' work in the same workspace.
GeneWorks installs the app into your instance as a safe, non-destructive update. Any changes made on the instance since your last deploy are merged in first, so your work never overwrites theirs. Every step is checkpointed — the whole deploy is fully reversible. GeneWorks never deploys straight to production.
GeneWorks runs ATF (server + client) plus live-browser functional tests against the deployed app — on our own test runner, so you never license ServiceNow's ATF cloud runner. Failures get one-click auto-fix where the pattern is known. Then your team signs off on the evidence. No theater: if 73 of 100 stories completed clean, it says exactly that — with a handoff for the rest.
The gates aren't ceremony. They're the contract. Every change record points to a named human who approved the design and a named human who approved the evidence. Audit trail by construction, not by reconstruction.
The agents have specified what they will build, why, and how it touches the rest of the instance. Now a human says yes or no. No code has been written yet. Reversing course here costs minutes — reversing it after build costs days.
The app is deployed and verified — ATF plus live-browser functional tests, on our own runner (no ServiceNow ATF cloud-runner license). The agents produce an evidence package per story: what passed, what's flagged, what's blocked. A human signs off before anything goes to CAB. No story is "done" because an agent says so.
Most ServiceNow AI tools sell a fantasy: type a story, get production code. The reality is messier — and we'd rather you plan around it than find out at deployment. Every artifact maps to one of three tiers based on real delivery data. HIGH means the agents handle it end-to-end. MEDIUM means the agents draft it and a human reviews. LOWER means the agents assist, but a senior engineer runs the work.
Reviewer effort: spot-check. The agents have a clean track record on these artifact types — review is a sanity pass.
Reviewer effort: meaningful. Architect reads the diff, runs the ATF, signs off. Same review as a junior dev's PR.
Reviewer effort: the agent is a junior pair-programmer. The architect designs and owns the work — the agent accelerates the mechanical parts.
Security boundaries are a human-architect call. Agents don't design ACLs.
Visual orchestrations remain in human hands.
IRE rules drive your single system of record. Don't let an agent guess.
Agents don't author dependency topology.
Frequency, rollup, and snapshot logic stay with the analyst.
Component composition is hand-crafted.
Patterns, credentials, schedules — human-owned.
Intent design and utterance curation is a domain task.
Identity is a security boundary, not an automation target.
Provisioning, certificates, network paths — infra team's domain.
The CAB calendar exists for a reason. Promotion is human-driven.
Cross-domain logic is a senior architect call.
If you're being told an AI tool can do all of this end to end, ask for proof. We don't claim it because it isn't true.
GeneWorks isn't one model wearing different hats. It's a roster of specialist agents — each scoped to a discipline, each with their own tooling, each with the prompts and patterns that produce reliable output for their artifact type. Gene is the orchestrator that routes work between them.
The continuous loop is live across ITSM and ITOM with full agent support. CSM, HRSD, FinOps, and SecOps follow on the published roadmap. Below is what's available now — and what each workspace handles end-to-end.
End-to-end ITSM delivery in the continuous loop — catalog item creation, business rule modifications, SLA reconfiguration, knowledge article authoring, change management workflow updates. Full ATF coverage on every build, every story, every release.
The ITOM agent handles event rule generation, alert correlation logic, threshold tuning, and CMDB CI class extensions. Service Mapping pattern configuration sits in the medium-fit tier; the underlying topology and dependency authoring stays human-owned.
Case management, omni-channel routing, account hierarchy, customer portal builds. Same continuous loop, same two human gates, same ATF coverage. Cross-workspace dependency awareness flags conflicts with ITSM routing automatically.
Employee lifecycle workflows, onboarding orchestration, HR case management, employee document templates. Bidirectional dependency tracking with ITSM (provisioning), CSM (employee-as-customer flows), and downstream identity systems.
The Integration agents handle Outbound REST messages, Scripted REST APIs (inbound), IntegrationHub spoke configuration, and transform maps. Authentication flow design, secret management, and gateway sizing remain human-driven.
Scoped app scaffolding, table design, business rules, client scripts, integration patterns, basic Service Portal widgets, full ATF coverage. The agent team delivers the build with documentation and tests included — not bolted on after.