Skip to content

ServiceNow development · coordinated by AI

Turn ServiceNow ideas into
working solutions.

Give the lead agent a requirement and it plans, builds, reviews, and verifies the solution with you—grounded in the ServiceNow SDK, your workspace, and live instance context.

From idea to verified artifact

A clear path from requirement to release

You stay in control while the team handles the specialist work behind the scenes.

01

Describe the outcome

Start with a requirement in plain language, from a new application to a production issue.

02

Coordinate the work

The lead agent reads your workspace and SDK context, then routes the task to the right specialists.

03

Build the solution

Focused developers create the Fluent artifacts, scripts, automation, UI, and tests you need.

04

Review and verify

Review findings, test results, and deployment steps stay visible before anything reaches your instance.

A Three-Tier Agent Architecture

15 coordinated agent definitions organized around one user-facing architect. The lead agent routes to support, coordination, review, and release agents, while the Fluent Developer delegates to focused specialists for each artifact type.

Tier 1: Orchestrator

NowDev AI Agent

The only user-facing entry point. It triages requests, creates implementation plans and Mermaid architecture diagrams, and coordinates the complete agent team.

PlanningDelegationArchitecture
Tier 2: Coordinator, Support, Review & Release
Assistant
Q&A & Discovery
Refinement
Story Refinement
Fluent-Developer
Fluent SDK Coordinator
Pipeline-Expert
CI/CD Pipelines
Debugger
Debugging Specialist
Fluent-Reviewer
Governance Reviewer
Fluent-Release
SDK Release
Tier 3: Fluent Specialists (internal)
Fluent Schema DeveloperFluent Logic DeveloperFluent Automation DeveloperFluent UI DeveloperAI Agent DeveloperNowAssist DeveloperATF Developer

Classic Guidance, Fluent Delivery

NowDev keeps classic platform knowledge available while making the Fluent SDK the primary implementation path for new metadata and full-stack work. The lead agent reads your workspace configuration and routes the request through the current SDK-aware workflow.

Classic

Traditional Scripting

The established ServiceNow development model using JavaScript server and client scripts. No additional toolchain required.

  • Classic JavaScript guidance remains available through native ServiceNow skills
  • Covers GlideRecord, Business Rules, Script Includes, Client Scripts, and integrations
  • No local SDK project is required for instance-side scripting
  • Useful for maintaining and extending existing ServiceNow implementations
Fluent SDK
Recommended for AI

Metadata as TypeScript

ServiceNow's official DSL for defining all platform metadata programmatically: tables, business rules, UI components, and more, as code that can be compiled, version-controlled, and deployed.

  • ServiceNow's official TypeScript SDK for metadata-as-code development
  • Builds tables, logic, automation, UI, AI Agent, NowAssist, and ATF artifacts
  • Uses now-sdk explain for API-accurate guidance tied to the installed SDK
  • Builds and validates artifacts before now-sdk install deploys them
  • Version-controlled, diffable, and reproducible across environments
Why Fluent works so well with AI: The installed SDK supplies current API guidance through now-sdk explain, while the build step catches type and schema problems before now-sdk install touches the instance. That gives the agent a fast, reviewable feedback loop.

Agents That Actually Know Your Platform

Agents draw from the installed ServiceNow SDK, official product documentation, native skills, workspace artifact state, and live instance data. That combination keeps plans and implementation grounded in the SDK version and the project you are actually working on.

SDK-aware development: now-sdk explain, build, install, query, sync, and auth workflows
Fluent artifacts: schema, logic, automation, UI, AI Agent, NowAssist, and ATF specialists
Classic platform skills: scripting, Business Rules, Client Scripts, security, dates, and forms
Live instance context: dependency browsing, discovery, KB guidelines, and query-backed planning
Workspace state: generated agents, instructions, prompts, and the Session Artifact Registry
Four profiles: Developer, Advanced Developer, Junior Developer, and Product Owner
Dynamic agent management, MCP detection, topology visualization, and model overrides
Work-item integration through project-management MCP servers such as Azure DevOps or Jira
Optional hooks and Artifact Manifest merge workflows for deterministic handoffs

Where agents get their knowledge

Installed SDK documentation

Agents use now-sdk explain for API reference, guides, examples, and CLI behavior tied to the SDK version in the project.

Product docs and supplemental sources

SDK and product llms.txt sources cover platform behavior, while optional MCP servers add team-owned context.

Instance-backed context

The Instance Browser uses the SDK auth alias and now-sdk query to inspect dependencies, discover related records, and prepare guidelines.

SDK-first development

Use the Fluent Developer coordinator and its schema, logic, automation, UI, AI Agent, NowAssist, and ATF specialists for complete application work.

AI, automation & UI

Specialists cover AiAgent definitions, agentic workflows, NowAssist Skill configuration, Flow Designer automation, React UI, client scripts, and workspaces.

Review, test & release

The Fluent Reviewer returns structured findings, ATF specialists generate tests, and the Fluent Release agent runs now-sdk build and now-sdk install.

A configurable workspace

Manage profiles, agents, tools, MCP integrations, model overrides, documentation sources, artifact state, and instance connections from the NowDev sidebar.

AI-Driven Workflow for ServiceNow Development

Don't just generate code. Refine the work, ground it in the installed SDK, build with specialists, and close the loop with review and verification.

NowDev-AI-Refinement

Refine & Discover

Refinement validates the user story, surfaces missing decisions, and produces a usable brief before full-project orchestration begins.

NowDev AI Agent

Plan & Coordinate

The lead agent reads workspace configuration and artifact state, creates a Mermaid architecture diagram, and routes the approved plan to the right coordinator.

Fluent Developer

Specialists Build & Review

The Fluent Developer delegates schema, logic, automation, UI, AI, and ATF work. The Fluent Reviewer checks the resulting artifacts and returns structured findings before release.

Fluent Release + Instance Browser

Install & Verify

The release agent runs the SDK build and install workflow. Instance Browser and the orchestrator can then inspect live records, forms, dependencies, and behavior for end-to-end confidence.

The Agentic Workflow for ServiceNow

A look at how NowDev AI Agent carries a requirement through the Fluent Developer, focused specialists, review, and release.

NowDev AI Agent

Lead Architect & Coordination Hub

Fluent Dev
Instance
Review
Release

Agentic Workflow

NowDev AI AgentFluent Developer

Route the approved brief with workspace and artifact context

Fluent DeveloperSchema Developer

Define the table, fields, roles, and access boundaries

Fluent DeveloperLogic Developer

Implement server-side behavior and Business Rules

Fluent DeveloperATF Developer

Generate tests for the completed artifacts

NowDev AI AgentFluent Reviewer

Validate artifacts and emit structured findings

Fluent ReviewerNowDev AI Agent

Review complete. Ready for fix, re-review, or release.

Multi-Agent Collaboration Showcase

A representative request handled by the current three-tier hierarchy. The lead agent reads workspace configuration, delegates through the Fluent SDK coordinator, and preserves handoff state in the artifact registry.

NowDev AI AgentTier 1: Lead Architect
"Build a table for equipment loan requests. Auto-assign to Equipment Support group when priority is set to Critical."
Workspace Context
>nowdev-ai-config.json → fluentApp + environment + artifactState → route to NowDev-AI-Fluent-Developer
Internal Monologue

Reading the workspace configuration and artifact registry… The project context and available tools are explicit. Creating a Mermaid architecture diagram, then handing the approved brief to the Fluent Developer with the discovered state.

Agent Implementation Plan
Syncing UI
Define x_equip_loan Table schema
Implement auto-assign server handler
Create BusinessRule (filterCondition: priority=1)
Validate with Fluent Reviewer
Architecture diagram generated. Routing to NowDev-AI-Fluent-Developer with the workspace context attached.
NowDev-AI-Fluent-DeveloperTier 2: Fluent SDK Coordinator
Installed SDK Documentation
>now-sdk explain --list table · now-sdk explain module-guide --format raw
Internal Monologue

Decomposing the plan. Table schema goes to the Fluent Schema Developer, server behavior and Business Rule go to the Fluent Logic Developer, and the shared artifact state records the dependency handoff.

Agent Implementation Plan
Syncing UI
Define x_equip_loan Table schema
Implement auto-assign server handler
Create BusinessRule (filterCondition: priority=1)
Validate with Fluent Reviewer
1// x_equip_loan.now.ts (Fluent-Schema Developer)
2import { Table, StringColumn, ReferenceColumn } from '@servicenow/sdk/core'
3 
4export const x_equip_loan = Table({
5 name: 'x_equip_loan',
6 label: 'Equipment Loan Request',
7 extends: 'task',
8 autoNumber: { prefix: 'ELR', number: 1000, numberOfDigits: 7 },
9 schema: {
10 equipment_name: StringColumn({
11 label: 'Equipment Name',
12 maxLength: 100,
13 }),
14 requested_by: ReferenceColumn({
15 label: 'Requested By',
16 referenceTable: 'sys_user',
17 }),
18 },
19})
20 
Fluent-Logic DeveloperTier 3: Logic Specialist
Built-in Skill
>skill("servicenow-fluent-development") → BusinessRule patterns & GlideRecord handler signature
Internal Monologue

Using the fluent-development skill and the installed SDK reference for BusinessRule ordering and handler patterns. The logic specialist reads the schema artifact first, then wires the assignment behavior with the correct current and previous record context.

Agent Implementation Plan
Syncing UI
Define x_equip_loan Table schema
Implement auto-assign server handler
Create BusinessRule (filterCondition: priority=1)
Validate with Fluent Reviewer
1// auto-assign.server.ts (server handler)
2import { GlideRecord } from '@servicenow/glide'
3 
4export function autoAssignHandler(
5 current: GlideRecord<'x_equip_loan'>,
6 previous: GlideRecord<'x_equip_loan'>
7) {
8 const gr = new GlideRecord('sys_user_group')
9 gr.addQuery('name', 'Equipment Support')
10 gr.setLimit(1)
11 gr.query()
12 if (gr.next()) {
13 current.setValue('assignment_group', gr.getUniqueValue())
14 current.setValue('urgency', '1')
15 }
16}
17 
18// equip-loan-rule.now.ts (BusinessRule metadata)
19import { BusinessRule } from '@servicenow/sdk/core'
20import { autoAssignHandler } from '../../server/business-rules/auto-assign.server'
21 
22export const equip_loan_auto_assign = BusinessRule({
23 $id: Now.ID['equip_loan_auto_assign'],
24 name: 'Auto-Assign Critical Requests',
25 table: 'x_equip_loan',
26 when: 'before',
27 action: ['insert', 'update'],
28 filterCondition: 'priority=1',
29 script: autoAssignHandler,
30 order: 10,
31 active: true,
32})
33 
NowDev-AI-Fluent-ReviewerTier 3: Fluent Review Specialist
Built-in Skill
>skill("servicenow-fluent-development") → validate schema, BusinessRule order & GlideRecord handler patterns
Internal Monologue

Cross-referencing the implementation against the SDK reference, local skills, and the reviewer checklist: schema consistency, dependency exports, BusinessRule behavior, security, performance, and test coverage.

Agent Implementation Plan
Syncing UI
Define x_equip_loan Table schema
Implement auto-assign server handler
Create BusinessRule (filterCondition: priority=1)
Validate with Fluent Reviewer
✅ Review complete. The reviewer emits structured findings so the orchestrator can delegate fixes, re-run review, or hand the validated artifacts to Fluent Release.

Install the NowDev AI Toolbox

Ensure your environment is ready for the ultimate ServiceNow development experience.

VS

VS Code 1.124.0+

Required for the current declarative Copilot agent and nested sub-agent experience.

GitHub Copilot Chat

Extension must be active to enable the specialized agent squad.

Enable nested agents

Allow the lead agent to invoke the Fluent Developer, which can then invoke its focused specialists.

Node.js + now-sdk Fluent

Install the ServiceNow SDK CLI for Fluent build, query, auth, and install workflows.

Installation Guide

Install from VS Code Marketplace

Click an install button above to open the extension page in VS Code where you can install it, or search for “NowDev AI Toolbox” in the Extensions Marketplace.

Enable nested sub-agents

Add “chat.subagents.allowInvocationsFromSubagents”: true to your VS Code settings.json. Without this, coordinators cannot invoke their specialists.

Install and initialise Fluent

Install @servicenow/sdk, add an auth alias with now-sdk auth --add, then use the sidebar or Command Palette to initialise a Fluent project.

Use the orchestrator

Open Copilot Chat, select NowDev AI Agent, and start with a requirement. The sidebar keeps agents, tools, MCP servers, docs, and artifact state in sync.

@NowDev AI Agent
Build an equipment loan workflow with an approval path.
# Coordinated plan
1. Read workspace + SDK context…
2. Delegate schema and logic…
3. Review, test, and release…

Beyond VS Code

The same orchestrated team in Copilot CLI and desktop

Install the generated plugin to use NowDev AI Agent through GitHub Copilot CLI or the Copilot desktop app. Claude Code users can copy the bundled instructions and reuse the skills.

View CLI setup

Support the Development.

Help me build specialized AI agents that empower you to create better solutions for ServiceNow. Your sponsorship directly supports the development of advanced AI tools designed for the modern developer.