NowDev AI Toolbox

Overview

NowDev AI Toolbox is a Visual Studio Code extension that provides specialized AI agents for ServiceNow development within GitHub Copilot Chat. Acting as a Lead Architect, the system orchestrates specialized sub-agents to plan, build, review, and deploy full-stack solutions.

Developed using the ServiceNow SDK official documentation, the extension integrates ServiceNow Best Practice Skills directly into GitHub Copilot, ensuring generated code adheres to strict performance and security standards. It is built around the Fluent SDK: agents fetch authoritative API details on demand via now-sdk explain and read live instance data via now-sdk query, so the SDK does the heavy lifting and stays current without bundled documentation. An AI Orchestrator breaks down requirements, visualizes architecture with Mermaid diagrams, and delegates tasks to specialized agents for schema, logic, automation, UI, and deployment.

Key Features

• AI Orchestrator: A master agent that breaks down requirements and delegates tasks to specialized sub-agents.
• Built-in Agent Skills: Automatically equips GitHub Copilot with verified knowledge of ServiceNow platform best practices.
• Automated Governance: A specialized reviewer agent inspects each artifact, dynamically selecting only the best-practice checks relevant to the artifact types actually present in the solution.
• Harness-Portable Agent Architecture: The orchestrator delegates directly to focused specialists (schema, logic, automation, UI, ATF, AI Studio, review, release). Agents use only the frontmatter and tool aliases every harness understands, so they behave the same in VS Code's default Copilot harness, the Local harness, the Copilot CLI and app, and (via the plugin) Claude Code.
• Official SDK Skill Aware: Agents load ServiceNow's official now-sdk skill first when it is installed. The sidebar detects it and shows how to install it.
• Interactive Workflow: Uses interactive tools to clarify requirements and validate designs.
• On-Demand Instance Diagnostics: Diagnostic agents can use available browser tools to inspect ServiceNow pages, capture screenshots, read visible state, and investigate client-side behavior when the task requires it. Verification is explicitly requested and tool-dependent; it does not run automatically in the background.
• Guided Setup: The sidebar's Home tab shows workspace status and the next setup steps, each linking to where it is fixed. Chat logs, diagnostics and a getting-started walkthrough are one click away in the sidebar's … menu.
• Dynamic Agent Management: Turn agents, agent bundles and individual tools on or off, and pick models, from the sidebar's Agents tab. Agent files update automatically. MCP server detection is automatic.
• Agent Topology Viewer: A panel that shows the orchestrator and its specialists grouped by role, which agents are on, and their models. It updates live as you change agents; select a card to open its agent file.
• User Profiles: Switch between Developer, Advanced Developer, Junior Developer, and Product Owner profiles. Each profile controls which agents are visible, adjusts communication tone, and (for Junior Developer) adds step-by-step educational commentary to every response — all without changing any configuration files.
• Instance Browser: Connect to your ServiceNow instance through your now-sdk auth alias to browse dependencies, discover related scripts and Knowledge articles, and prepare KB-backed agent guidelines from one unified panel — all powered by now-sdk query, with no separate credential store.
• Work Item Integration: Connect a project-management MCP server (Azure DevOps, Jira, etc.) and the orchestrator automatically reads the linked task before building, posts progress comments as each artifact completes, and updates work-item status on completion — driven entirely by the MCP server, no dedicated agent required.

Installation & Usage

Prerequisites

• Visual Studio Code 1.142 or later. The agents target the default Copilot harness and also work in the Local harness.
• GitHub Copilot Chat extension
• For Fluent work: Node.js 20.18+ and the ServiceNow SDK (@servicenow/sdk) 4.6 or later; now-sdk query needs 4.8+.
• Recommended: ServiceNow's official now-sdk agent skill (gh skill install ServiceNow/sdk now-sdk). The bundled SDK skill loads it first. Settings › Environment tools in the sidebar shows whether it was found, with install guidance when it was not.
• The extension never changes your VS Code settings on its own. Settings › Copilot settings in the sidebar lists recommended settings, such as browser tools and forked skill context, and changes them only when you click Enable.

Documentation Sources

Agents use four knowledge channels, with supplemental sources configurable from the NowDev AI Toolbox sidebar:

Source	What it covers	Default
now-sdk explain (always-on)	Fluent SDK API reference, guides, examples, and CLI behavior — local CLI tied to the installed SDK version	Always enabled
SDK llms.txt	Supplemental SDK documentation index when now-sdk explain does not cover a topic	https://servicenow.github.io/sdk/llms.txt
Product llms.txt	General ServiceNow platform docs	https://www.servicenow.com/llms.txt
MCP server	Your own indexed sources (optional)	None

The bundled nowdev-ai-toolbox-servicenow-sdk skill is the sole authority for now-sdk command mechanics. It owns command and flag discovery, authentication-alias handling, output envelopes, pagination, error classification, secret handling, and mutation approval. Other agents and skills define why data or documentation is needed and how results should be interpreted, but delegate command construction to the SDK skill instead of duplicating CLI instructions.

For Fluent SDK work, the SDK skill discovers the installed CLI's current syntax and uses now-sdk explain to retrieve API documentation tied to that SDK version before agents rely on local guidance. Local skills focus on ServiceNow domains, NowDev workflows, interpretation, and small opinionated guardrails. To configure supplemental sources, open Settings › Documentation sources in the NowDev AI sidebar.

Connecting to Your ServiceNow Instance

The Instance Browser connects to a ServiceNow instance through the ServiceNow SDK's own authentication. Credentials are managed entirely by now-sdk (stored in the SDK keychain) — the extension does not keep a separate credential store.

1. Add an instance. Use Add instance… on the sidebar's Project tab, or run NowDev Instance: Add Instance…. The wizard asks for the URL, an optional alias and the sign-in type, then finishes in a terminal: OAuth asks you to paste the authorization code, basic asks for a password. Instances you already added with now-sdk auth --add are picked up automatically.

2. Pick the active instance. With several instances, pick the one this workspace uses from the header chip, the status bar or Use on the Project tab. SDK commands, the Query panel, the Instance Browser and the agents all use it. Click Test to check the connection.

3. Open the Instance Browser. Its modes:

   • Browse: find records and add them to now.config.json.
   • Discover: find related scripts and Knowledge articles for a task.
   • Guidelines: attach KB articles as agent guidelines.
   • Dependencies: review what is already declared.

   All reads run through now-sdk query --auth <alias>.

4. Query any table. Query data… on the Home tab, or NowDev Instance: Query Table…, opens the Query panel beside your editor. Select a row to see every field.

The status bar shows the active instance and the last connection result. Click it to switch instance, test the connection, query data or open the Instance Browser.

Work Item Integration (Azure DevOps, Jira, etc.)

NowDev can drive your project-management tool through any MCP server, with no dedicated agent. When enabled, the orchestrator (NowDev AI Agent) reads the linked work item before building, posts a progress comment as each artifact completes, and updates the work item's status on completion.

1. Install/add a project-management MCP server (e.g. an Azure DevOps or Jira MCP server) so it appears under Settings › MCP servers in the sidebar.
2. In Settings › Work item integration, turn it on and pick that MCP server.
3. (Optional) Browse to a .md/.txt file describing your team's task structure, naming conventions, and status values — this is injected into the orchestrator's work-item mandate.
4. Start a full-project request and reference the task ID; the orchestrator handles the read/comment/status-update workflow automatically.

The configuration is saved in .vscode/nowdev-ai-config.json under devopsConfig, so existing setups continue to work unchanged.

Getting Started with Fluent SDK

If you are starting a new ServiceNow Fluent SDK project, the NowDev AI Toolbox provides a guided onboarding flow:

1. Install the ServiceNow SDK CLI globally (requires Node.js 20.18 or newer):

   npm install -g @servicenow/sdk
   

   If it's missing, the sidebar's Home tab shows an Install the ServiceNow SDK step that runs this for you (also NowDev SDK: Install now-sdk).

2. Open the NowDev AI Toolbox sidebar by clicking the activity bar icon.

3. Start the wizard. Choose Initialize… in the sidebar's next steps (shown when no now.config.json is detected), run NowDev AI: Initialize Fluent Project… from the Command Palette, or right-click a folder in the Explorer.

4. Answer the wizard. It asks one step at a time, with Back support:

   • Start a new app, convert an app from the instance, or adopt a local folder.
   • The app name, package name, scope, template, credential and location.

   It warns before using a folder that isn't empty. It then runs now-sdk init and npm install with cancellable progress; the output goes to the NowDev AI: Init Fluent Project output channel.

Once it completes, the sidebar detects the new now.config.json, shows your Fluent app details, and the SDK commands become available, including Deploy, Build and Sync in the editor title bar of now.config.json.

The Sidebar

Tab	What it is for
Home	Workspace status at a glance, the next setup steps, and quick actions: agent chat, Query data, Explain SDK API, Instance Browser, Agent topology
Project	Connected instances and the active one, the connection check, Deploy/Build/Install/Sync and the other SDK commands
Agents	The agent profile and tone instructions; core, bundled and optional agents with switches, model selection, tool lists, model presets and the topology
Settings	Recommended Copilot settings, the Fluent project, instructions and KB guidelines, MCP servers, work item integration, documentation sources and environment tools. Sections that are already set up start collapsed

The sidebar follows your color theme (light, dark and high contrast), works at narrow widths, and can be used with the keyboard and a screen reader.

Commands

Commands are in the Command Palette under four categories: NowDev AI, NowDev SDK, NowDev Instance and NowDev Copilot. SDK commands appear when the workspace has a now.config.json, and instance commands once an instance is connected. A few internal commands that only menus use are hidden from the palette.

Command	What it does
NowDev SDK: Deploy (Build, then Install)…	Builds, then installs; stops if the build fails. Ctrl+Alt+D (Cmd+Alt+D) in Fluent projects
NowDev SDK: Build…, NowDev SDK: Install…	Run a single step, with optional flags
NowDev SDK: Sync from Instance	Incremental download, then transform to Fluent source
NowDev SDK: Transform…, Download Metadata…, Download Dependencies, Move Global Metadata…, Clean, Pack	The remaining now-sdk commands
NowDev SDK: CI/CD…, Run now.config Script…	now-sdk cicd operations and project scripts
NowDev SDK: Show Last Deployment, Check for Instance Changes	Results appear on the sidebar's Project tab
NowDev SDK: Explain API…	Opens now-sdk explain documentation in a panel with search and Back
NowDev SDK: Install now-sdk	Installs the ServiceNow SDK globally in a terminal
NowDev AI: Initialize Fluent Project…	The project wizard described above
NowDev Instance: Add Instance…, Remove Instance…, Switch Active Instance…, Set SDK Default Credential…	Manage instances and now-sdk credentials
NowDev Instance: Query Table…	Opens the Query panel
NowDev Instance: Test Connection, Open Instance Browser, Discover Context, Copy Auth Header…	Instance tools
NowDev Instance: Show Instance Actions…	The menu behind the status bar item
NowDev AI: Show Agent Topology, Manage Knowledge Base Guidelines	Agent views
NowDev Copilot: Open Agent Chat, Show Chat Logs, Collect Diagnostics, Open Agent Customizations, Review Recommended Settings	Copilot helpers
NowDev AI: Open Getting Started, Open Settings, Refresh Sidebar	Walkthrough and sidebar helpers

Right-click now.config.json (or use its editor title bar) for Deploy, Build, Sync and Run Script, and right-click a metadata folder for Transform from Here.

Output and errors. SDK output goes to one NowDev AI: SDK output channel, which opens when a command fails; change this with nowdev-ai-toolbox.sdk.revealOutput. Failures show a notification with Retry and Show Output, and Re-authenticate… when the instance rejected the credential. Set nowdev-ai-toolbox.sdk.confirmDeploy to be asked before Install and Deploy.

Recommended Workflow

Always start with NowDev AI Agent for any new task or feature. The orchestrator will:

• Analyze your requirements and create a detailed implementation plan
• Break down complex tasks into manageable steps
• Coordinate between specialized agents as needed
• Ensure all work follows ServiceNow best practices

You can also use specialized agents directly for specific tasks, but starting with the orchestrator ensures proper planning and coordination.

Workspace Customizations

NowDev writes modern VS Code Copilot customization files into the workspace when agents are synced:

File location	Purpose
.github/agents/*.agent.md	Generated custom agents for the active profile, tools, MCP servers, and enabled agent set
.github/instructions/nowdev-ai.instructions.md	Workspace-wide NowDev context, cross-agent handoff protocol, custom instructions, and selected instance guidelines
.github/skills/nowdev-ai-toolbox-*/	The bundled ServiceNow skills, synced so every harness (Copilot, Local, Copilot CLI, cloud agent) can load them
.github/skills/nowdev-{start,review,compact}/	/nowdev-start, /nowdev-review, /nowdev-compact workflow skills. These replace the old prompt files, which the Copilot harness does not load.

All generated files carry a # nowdev-managed stamp and are added to .gitignore. Sync never overwrites or deletes files without that stamp, so your own agents and skills, including an installed official now-sdk skill, are left alone. Managed .github/prompts/nowdev-*.prompt.md files from older versions are removed on the next sync. Sync runs automatically in Fluent projects (now.config.json) and in any workspace you have synced manually once.

Cross-agent handoffs use a lightweight, in-context convention instead of a persisted file: specialists end each response with a "Files Touched" list (path, purpose, key exports), coordinators carry that list into subsequent delegation prompts, and reviewers always read the actual source files before trusting a claimed export. This keeps handoffs accurate without a separate state file to keep in sync.

The sidebar's Agents tab supports per-agent model overrides and role-aware model presets based on the chat models VS Code reports as available. Presets write a model: fallback list, and the harness uses the first available model. Planning, review and debugging agents get the strongest models, implementation specialists balanced ones, and the Assistant a fast one. Each bundled agent also declares a reasoning-effort. Keep bundled agents mostly unpinned unless a team has a clear quality, latency, or cost reason to override them.

Memory is optional. If Copilot memory is unavailable or disabled by an organization, NowDev still coordinates handoffs through the in-context Files Touched protocol above. The sidebar reports administrator-managed preview features without showing impossible fix buttons.

Example Usage

Open GitHub Copilot Chat, select "NowDev AI Agent" from the agent dropdown, and type:

I need to create a custom ServiceNow application for managing IT assets with approval workflows

Customizing Agent Behavior

The nowdev-ai-toolbox.customInstructionsFile setting lets you supply a Markdown or plain-text file whose contents are injected into every agent session as the highest-priority directives — overriding built-in defaults where they conflict.

This is the primary mechanism for enforcing org-specific standards:

• Coding conventions and framework preferences (e.g. "always use Fluent SDK")
• Naming rules (scope prefix, casing, identifier patterns)
• Forbidden patterns (e.g. eval(), N+1 queries, hard-coded sys_id values)
• Unconditional "always use / never use" directives

How to Configure

1. Copy agents/github-copilot/CUSTOM-INSTRUCTIONS-TEMPLATE.md to a path of your choice (e.g. ~/nowdev-custom-instructions.md).

2. Edit the file to reflect your team's standards.

3. Point the extension at your file using one of these methods:

   Option A — Sidebar (recommended): Click the NowDev AI Toolbox icon in the VS Code Activity Bar to open the sidebar panel. On the Settings tab, open Instructions & guidelines and click Choose file…. The path is saved automatically to your global VS Code settings.

   Option B — VS Code Settings: Open Settings (Ctrl+,), search for nowdev-ai-toolbox, and paste the absolute path into the Custom Instructions File field (under NowDev AI).

The extension reads the file on every save, writes its content into .vscode/nowdev-ai-config.json under the customInstructions key, and injects the same content into generated workspace agents as Workspace Guidelines so changes reliably affect agent behavior.

Instance-Backed Guidelines

Teams can keep coding standards, review rules, and release policies in ServiceNow Knowledge Base articles. Use Settings › Instructions & guidelines → Choose articles… in the sidebar, the NowDev AI: Manage Knowledge Base Guidelines command, or the Guidelines mode of the Instance Browser to find relevant kb_knowledge articles from the authenticated instance. Selected articles are saved in .vscode/nowdev-ai-config.json as guideline references. Generated agents receive those references and delegate live retrieval to the SDK skill when article content is needed.

Note: .vscode/nowdev-ai-config.json is auto-generated and is automatically added to .gitignore. It should not be committed to source control.

Project Copilot Instructions

For repository-wide Copilot behavior, create .github/copilot-instructions.md. The NowDev AI Agent can inspect a ServiceNow workspace and draft project-specific instructions from detected facts such as Fluent vs Classic style, scope prefix, artifact folders, naming patterns, validation commands, and forbidden patterns.

Ask the NowDev AI Agent to generate Copilot instructions for the current project when:

• The workspace has no .github/copilot-instructions.md
• Copilot suggestions are using the wrong ServiceNow style or scope
• You want team-wide standards committed with the repository
• You changed architecture, folders, validation commands, or naming conventions

If you also want NowDev agents to receive the same standards, keep using the existing custom instructions file flow above. The generated project instructions and NowDev custom instructions solve related but different problems: .github/copilot-instructions.md is repository-wide Copilot context, while the NowDev custom instructions file is injected into generated NowDev agents.

Efficient Copilot Usage

• Use planning/refinement first for multi-artifact work, then implement from the approved brief.
• Start a new chat for unrelated tasks, fork when exploring alternatives, and compact long sessions when continuing the same task.
• Disable unneeded tools or MCP servers for a request when they are not relevant.
• Keep generated files such as .github/agents/** and out/** excluded from search so agent discovery does not spend context on generated output.
• Use efficient model choices for simple edits and reserve higher reasoning effort for planning, architecture, and debugging.

Template Sections

The template covers these sections (all optional):

Section	Purpose
## Development Preferences	Default framework, SDK version, coding style
## Naming Conventions	Scope prefix, table names, casing rules
## Scope and Application	Restrict changes to specific scopes/apps
## Excluded Patterns	Hard-forbidden APIs and practices
## Always Use / Never Use	Unconditional short-form directives

User Profiles

Switch profiles from the NowDev AI Toolbox sidebar to instantly reshape how every agent behaves — no config files needed.

Profile	Who it's for	What changes
Developer (default)	Experienced ServiceNow developers	Core development agent set; the AI Agent Studio and NowAssist specialists are hidden
Advanced Developer	Developers using the full platform surface	Every bundled agent enabled, including the AI Agent Studio and NowAssist specialists
Junior Developer	Developers learning ServiceNow	Same agent set as Developer, but every response adds step-by-step explanations, term definitions, pitfall callouts, and follow-up learning suggestions
Product Owner	Business stakeholders managing requirements	Development agents hidden; discovery, refinement, and (when a work-item MCP server is configured) work-item management visible; plain-language communication, no code

Specialized Agents

The topology is flat: you talk to the orchestrator, and it delegates directly to each specialist. The default Copilot harness delegates by agent description. It does not honour agents: allow-lists, handoff buttons, or nested coordinators. Every specialist therefore has a routing-oriented description, and the orchestrator's routing table names the Fluent APIs each one owns.

Agent	Role
NowDev AI Agent	Lead Architect. Triages requests, plans, gets approval, delegates, and tracks progress. The only agent in the picker.
NowDev-AI-Assistant	Lightweight Q&A, brainstorming, and early discovery
NowDev-AI-Refinement	User-story refinement and feasibility validation before every full project
NowDev-AI-Fluent-Schema-Developer	Tables and columns, Records, Roles, ACLs, Data Policies, Forms, Lists, Database Views, State Models, Properties, Menus, Cross-Scope Privileges, dictionary overrides, Instance Scan checks, $override, protectionPolicy, Now.del
NowDev-AI-Fluent-Logic-Developer	Business Rules, Script Includes, Script Actions, Scheduled Scripts, REST APIs, REST Messages, GraphQL APIs, Email Notifications, Inbound Email Actions, Interceptors, SLAs, Aliases, Retry Policies, Data Lookups, server modules
NowDev-AI-Fluent-Automation-Developer	Flows, Subflows, Actions and steps, triggers, Flow Stages, Try/Catch, Do-in-Parallel, Playbooks, Assessments
NowDev-AI-Fluent-UI-Developer	UI Pages (React, Vue, Svelte, SolidJS with Vite/HMR), Client Scripts, UI Policies, UI Actions, Service Catalog, Service Portal, Workspaces, Dashboards
NowDev-AI-AI-Agent-Developer	AiAgent and AiAgenticWorkflow
NowDev-AI-NowAssist-Developer	NowAssistSkillConfig
NowDev-AI-ATF-Developer	ATF Tests and Test Suites
NowDev-AI-Debugger	Runtime error diagnosis and performance analysis (read-only)
NowDev-AI-Fluent-Reviewer	Reviews every artifact against installed SDK docs and NowDev guardrails (read-only)
NowDev-AI-Fluent-Release	Build, approved install, pack, and CI/CD install, publish, and rollback, through the SDK skill

Architecture

The extension renders its bundled agents and skills into the workspace (.github/agents, .github/skills, .github/instructions), applying your profile, tools, MCP servers, documentation sources and model presets. These are the locations the Copilot harness, the Local harness, the Copilot CLI and the cloud agent all read. VS Code's API for adding agents at runtime is still proposed, and static chatAgents contributions cannot carry per-workspace customization, so the extension writes files instead.

Agent Capabilities

• Specialized Knowledge: Deep expertise in specialized ServiceNow domains.
• Native Skills: Verified best-practice skills load on demand into the agent's context window.
• Orchestration: The orchestrator delegates by dependency batch (Schema → Logic → Automation/UI/AI Studio → ATF), runs independent specialists in parallel, and sends every artifact to the Reviewer.
• Harness Portability: Agents use only name, description, tools (aliases read, search, edit, execute, web, agent, todo), user-invocable, disable-model-invocation, model and reasoning-effort. npm run validate:agents enforces this.

Code Examples

Canonical Exemplars

agents/exemplars/ contains minimal reference files for each artifact type — the "what good looks like" shapes that agents pattern-match when generating code:

Category	Files
Fluent SDK	Table + Role + ACL, ScriptInclude, BusinessRule, ATF Test
Classic scripting	GlideRecord, Script Include, GlideAjax, Business Rule, Client Script

Included Skills

The extension ships 13 skills, synced into .github/skills, plus three workflow skills. They are organized by responsibility instead of duplicating Fluent SDK API documentation:

• SDK and development: Canonical now-sdk CLI authority, NowDev Fluent development routing and guardrails, and ServiceNow Horizon React components.
• Planning and test data: Instance-grounded implementation planning and anonymized ATF fixture generation.
• Live diagnostics: Access-denied analysis, incident/log triage, notification-delivery tracing, recent-change correlation, and cross-environment drift auditing.
• Governance and communication: Knowledge Base compliance checks and multilingual incident responses.
• Platform awareness: Official ServiceNow release-note retrieval and comparison.

Domain skills own intent, evidence requirements, interpretation, and reporting. Whenever they need installed SDK documentation or live instance data, they delegate CLI mechanics to nowdev-ai-toolbox-servicenow-sdk. That skill is now a thin wrapper: it loads ServiceNow's official now-sdk skill first and adds NowDev guardrails, such as no npx, approval gates for install, CI/CD, auth and move, and credential safety. When the official skill is missing, it falls back to the SDK's installed docs.

Agent Definitions

Each AI agent is defined in declarative format:

• View Agent Definitions

Agent Maintenance

Bundled VS Code agents are maintained in agents/github-copilot/. Generated workspace agents in .github/agents/ are managed output and should be regenerated by the extension rather than edited directly.

Before changing bundled agents, read agents/github-copilot/AGENT-PATTERNS.md. The contract:

• Only the orchestrator is user-invocable: true and has the agent tool.
• Specialists are user-invocable: false and disable-model-invocation: false, so the harness can delegate to them.
• There are no agents:, handoffs: or argument-hint: fields.
• Tools use the portable aliases.
• Every specialist is named in the orchestrator's routing table and in src/AgentTopology.ts.

Run the validation command before publishing or packaging agent changes:

npm run validate:agents
npm run build:plugin   # regenerate the Copilot / Claude Code plugin
npm run check:plugin   # fails if the committed plugin is out of date (runs in prepublish)

Included Examples & Attribution

This project adapts code examples from the ServiceNow SDK Examples Repository (MIT License) within some of the agent skills. Where present, a skill's EXAMPLES.md file contains working code examples demonstrating best practices.

For details on third-party licenses and attribution, see THIRD_PARTY.md.

License

This project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.

Code examples adapted from the ServiceNow SDK Examples Repository are licensed under the MIT License - see LICENSES/MIT-ServiceNow-SDK.txt for details.

Using NowDev AI Toolbox with Claude Code

The toolbox ships a Claude Code plugin built from the same sources:

/plugin marketplace add DanielMadsenDK/NowDev-AI-Toolbox
/plugin install nowdev-ai-toolbox@nowdev-ai-toolbox
/nowdev-ai-toolbox:nowdev-ai-agent <describe your ServiceNow task>

Claude Code subagents cannot spawn further subagents, so the orchestrator ships as a skill that your main session follows. Specialists ship as subagents (nowdev-ai-fluent-schema-developer, …). Also install ServiceNow's SDK plugin with /plugin install servicenow-sdk@claude-plugins-official. See agents/claude-code/README.md.

Using NowDev AI Toolbox with the GitHub Copilot CLI & App

The same plugin is an Agent Plugins 1.0 package for the GitHub Copilot CLI, the Copilot app, and VS Code agent plugins:

copilot plugin marketplace add DanielMadsenDK/NowDev-AI-Toolbox
copilot plugin install nowdev-ai-toolbox@NowDev-AI-Toolbox

Run /agent, pick NowDev AI Agent, and describe your ServiceNow task.

The plugin ships the agents and skills only. The extension's management UI, documentation sync, SDK commands and one-click configuration remain VS Code-exclusive. See plugins/nowdev-ai-toolbox/README.md.

Author

Daniel Aagren Seehartrai Madsen - ServiceNow Rising Star 2025

Dedicated to elevating the standard of ServiceNow development through AI innovation.