Now Assist is ServiceNow's generative AI product, embedded directly into the platform across ITSM, HR, CSM, Creator, and more. Rather than a separate AI tab, it appears at the point of work (inside the incident form, the case view, Studio, and Flow Designer) so agents and developers get AI assistance without switching context.

• Summarisation – Condenses long incident work notes, case history, or chat logs into a brief so agents understand context immediately.
• Content generation – Drafts email replies, resolution notes, and knowledge articles based on the record's context.
• Code and flow generation – Writes ServiceNow scripts and Flow Designer actions from natural language descriptions in Studio.
• Search – Returns a direct generated answer to a natural language query rather than a list of article links.

Now Assist ships with a set of OOTB skills that cover the most time-consuming repetitive tasks across service management and development.

• Incident Summarisation – Compresses all work notes into a 3-4 line brief visible when an agent opens the incident.
• Response Suggestion – Drafts a contextual reply to the caller or customer based on the incident or case content.
• Resolution Note Generation – Auto-drafts a resolution note when a ticket is closed, saving 3-5 minutes per ticket on documentation.
• Knowledge Article Generation – Converts a resolved incident or case into a draft knowledge article for review and publishing.
• AI Search – Understands natural language queries and returns a generated answer with citations, not just a list of links.
• Code Generation – Produces Business Rule, Script Include, and Client Script code from a plain-English description in Studio.
• Flow Generation – Builds Flow Designer action sequences from a description of the trigger and steps.
• Chat Summarisation – Condenses a live chat or email conversation for an agent joining mid-interaction.

Now Assist for ITSM embeds AI assistance directly into the incident form so agents spend less time reading, writing, and documenting.

When an agent opens a high-activity incident, Now Assist displays a compressed summary of all work notes and comments. The agent understands the history in seconds without scrolling through 40 entries.

When an agent composes a work note or customer-facing reply, Now Assist drafts the message based on the incident details, the caller's question, and resolution patterns from similar closed incidents.

After the agent marks the incident resolved, Now Assist drafts a resolution note using the ticket history. The agent reviews and accepts or edits it, the documentation step that normally takes 4 minutes takes under 30 seconds.

With one click, Now Assist converts a resolved incident into a draft knowledge article in the correct template, ready for a knowledge manager to review and publish.

Now Assist for Creator embeds AI assistance in Studio and Flow Designer, allowing developers to generate ServiceNow-specific scripts and flows from natural language descriptions.

A developer describes what a Business Rule, Script Include, or Client Script should do. Now Assist generates the full script with correct GlideRecord syntax, field names, and structure. The developer reviews before accepting.

A developer describes the trigger, conditions, and steps. Now Assist generates the action sequence in Flow Designer, which the developer reviews and completes with field mapping and conditions.

A developer describes the application they want to build — the purpose, the tables, and the main workflow. Now Assist scaffolds the initial app structure: tables with field suggestions, a basic form layout, and a starter flow. The developer then refines each component rather than starting from a blank canvas.

Describe what a script or business rule should do in plain English and Now Assist generates the corresponding Automated Test Framework (ATF) test steps. This closes the gap between writing code and writing tests for it, which most developers skip under deadline pressure.

Inside the Script Editor, Now Assist provides context-aware inline suggestions as the developer types — similar to GitHub Copilot but aware of the ServiceNow platform APIs, GlideRecord patterns, and the current record's table and field context.

Paste an existing script into the AI Assist panel and ask “What does this do?” Now Assist returns a plain-English explanation, useful for understanding legacy code or reviewing generated scripts.

They serve different audiences and purposes and are designed to work together, not compete.

A conversational chatbot for end users (employees or customers). It follows Topic Designer conversation flows, asks questions, and takes actions like resetting a password or checking ticket status. It can now deliver responses using generative AI for more natural language.

An AI layer embedded inside ServiceNow for human agents, developers, and admins. It does not have a conversation flow, it generates content in context: summarises a ticket the agent just opened, drafts a reply the agent is composing, or writes a script the developer is building.

Virtual Agent deflects L0 and L1 tickets by resolving the user's request autonomously. Tickets that still reach a human agent are handled faster because Now Assist provides instant context, drafts replies, and generates resolution notes.

AI Search replaced the legacy Zing search engine. The fundamental difference is the output: standard search returns a ranked list of matching records; AI Search returns a direct generated answer.

Returns a list of articles and records ranked by keyword relevance. The user must open and read several articles to find the answer. Works on exact and partial keyword matching.

Uses semantic search (Natural Language Understanding) to match intent, not just keywords. Combined with Now Assist, it generates a 2–4 sentence answer at the top of results, synthesised from the most relevant articles, with citations to the source content.

A user searches “I can't get into my computer.” Standard search returns articles with those exact words. AI Search understands the intent and surfaces password reset and MFA lockout articles, then generates a direct answer: “If you cannot log in, first try resetting your password at... If the issue persists, contact IT support at...”

AI Search also self-improves: it learns from which results users click, adjusting relevance rankings automatically.

Predictive Intelligence (PI) and Now Assist are both AI features in ServiceNow, but they use different technology for different purposes and they are complementary, not interchangeable.

Uses classic machine learning trained on your own historical data. It makes predictions about structured field values: which category an incident belongs to, which assignment group should handle it, which knowledge articles are similar. Output is always a predicted field value.

Uses large language models (LLMs) pre-trained on massive datasets and fine-tuned on ServiceNow content. It generates new content, summaries, draft replies, scripts, flow logic. Output is always generated text or code.

The Now Assist Skill Kit (NASK) is ServiceNow's low-code/pro-code framework for building and deploying custom AI skills beyond the out-of-the-box Now Assist capabilities. It allows developers and advanced admins to extend the AI platform to address organisation-specific needs that OOTB skills do not cover.

Out-of-the-box Now Assist skills (incident summarisation, response suggestion, knowledge article generation) work well for generic tasks. But every organisation has unique AI use cases that require custom context: a manufacturing company needs skills drawing from equipment maintenance runbooks; a bank needs skills reasoning over proprietary financial policy documents; an IT team needs a skill that queries an internal CI topology database before generating remediation guidance.

• Pull context from a specific ServiceNow knowledge base, custom table, or external API as the retrieval source
• Run server-side JavaScript to pre-process retrieved data before it reaches the LLM
• Call a Flow Designer Subflow as part of the skill pipeline, enabling the AI output to also trigger automated actions
• Chain multiple skills where the output of one skill becomes the input of the next, enabling multi-step AI workflows
• Use a custom LLM (BYOLLM) instead of the platform default
• Trigger via a UI Action button, a custom form element, or a Flow Designer step

Every custom NASK skill is structured around five official components. Understanding the two-level architecture (skill components vs. tool types within those components) is what separates a practitioner answer from a memorised list.

Parameters the skill receives when triggered: string values, boolean flags, GlideRecord references, or data from a conversation context. Inputs define what the skill knows about the current record or situation before any processing begins. A skill triggered from an incident form typically receives the incident sys_id, short description, and category as inputs.

The natural-language instructions passed to the LLM. ServiceNow prescribes a four-section structure: Role (what the AI should act as), Context (the retrieved content injected at runtime), Instructions (what to do and what to avoid), and Output (the required format, length, and structure of the response). The Prompt is the most impactful component for output quality.

The actions and data sources the skill can use before or alongside the LLM call. Tools is the umbrella component; the specific tool types available within it are:

• Retriever – Implements RAG (Retrieval-Augmented Generation). Searches knowledge bases, custom tables, or connectors and injects the most semantically relevant content chunks into the prompt context.
• Script – Server-side JavaScript that pre-processes input data before the LLM call or post-processes LLM output (validate format, write a field, extract a value).
• Sub Flow – Invokes a published Workflow Studio subflow to collect supplemental data or trigger automation as part of the skill pipeline.
• Flow Action – Invokes individual Flow Designer actions as a tool step.
• Web Search – Retrieves real-time information from the internet (search/scrape or AI Answer mode).
• Decision – Conditional branching: run Tool A first; fall back to Tool B if it returns nothing.
• Skill – Calls another published NASK skill as a tool step. This is the mechanism that enables Skill Chaining: it is a tool type, not a separate building block.

Structured data returned by the skill after the LLM call. Five standard outputs are auto-generated: response (the generated text), confidence, explanation, metadata, and citations. Custom output fields can be added for structured responses (e.g., a JSON object with classified clause types).

Configuration controlling where and how the skill is exposed: as a UI Action button on a form, inside the Now Assist Panel, or as a Flow Designer “Execute Skill” action. This is what determines how agents actually trigger the skill in their daily workflow.

Skill Chaining is a capability, not a component. It works by adding a published skill as a Skill tool type on another skill, so the output of Skill A becomes the input of Skill B.

Now Assist spans all major ServiceNow product lines. Each module has a dedicated set of skills tuned to that domain's workflows.

• Now Assist for ITSM – Incident summarisation, response suggestion, resolution note generation, knowledge article generation from resolved incidents.
• Now Assist for HR Service Delivery – HR case summarisation, agent response drafts, knowledge generation for HR policies, employee enquiry handling.
• Now Assist for Customer Service Management (CSM) – Case and chat summarisation, live response suggestions (Agent Assist), customer communication drafts.
• Now Assist for Field Service Management (FSM) – Work order summaries, technician task briefings, guided resolution support for field teams.
• Now Assist for Security Operations – Security incident triage summaries, threat briefing generation, alert correlation narrative.
• Now Assist for Creator – Script generation, flow generation, code explanation, and test suggestion inside Studio and Flow Designer.

The Now Assist Admin Console (All → Now Assist → Admin Center) is the central management console for all AI capabilities in a ServiceNow instance. It replaced the scattered per-module Now Assist configuration with a single location for all AI administration.

• Activate and deactivate Now Assist skills per department or module
• Configure which LLM provider a skill uses (Now LLM, Azure OpenAI, Claude, Gemini, BYOLLM)
• Monitor skill usage: activation rates, acceptance rates, agent feedback scores
• Set custom prompt parameters and context sources for individual skills
• Configure AI Search settings, knowledge sources, and index scope
• View AI Control Tower governance status (for licensed AI governance features)

The Now Assist Admin Console provides three categories of metrics that together give a complete picture of adoption health. It is the primary tool for diagnosing whether Now Assist is working, trusted, and actually saving agent time.

• Total skill triggers – How many times the skill ran during the period. Low triggers mean agents are not clicking the skill button, an awareness or UI placement problem.
• Unique users – How many distinct agents used the skill. High trigger count with low unique users means a few power users are driving all activity, adoption is concentrated, not widespread.

• Acceptance rate – The percentage of suggestions agents accepted without modification. This is the most important single metric. High acceptance = agents trust the output. Low acceptance = agents trigger the skill out of curiosity but reject what it produces.
• Modification rate – Percentage accepted after editing. High modification rate with high acceptance signals the model is directionally correct but needs language tuning, better knowledge content or prompt refinement will help.

• High activation + low acceptance → agents see suggestions but reject them → review knowledge content and context source configuration
• Low activation → agents are not triggering the skill → investigate UI placement, awareness, or training
• High modification rate → output direction is right but needs calibration → review prompt configuration

Now Assist includes several built-in and configurable safety controls that sit between the LLM output and what the agent actually sees.

All Now Assist output passes through content safety filters before display. These block outputs containing discriminatory language, content violating platform content policies, or unexpected PII in output fields. These filters run regardless of which LLM provider is configured.

ServiceNow structures prompts to separate the skill's system instructions from user-controlled content. This reduces the risk of prompt injection, where malicious content in a ticket field attempts to redirect the AI's behaviour. An agent's work notes cannot override the skill's core system prompt.

For skills configured with a confidence threshold, if the model cannot produce a response adequately supported by the context, it returns no suggestion rather than a low-quality guess. The agent sees an empty suggestion panel, no output is better than wrong output in this design.

For output with consequences (knowledge article publishing, resolution notes on high-priority incidents) configure a mandatory review step before AI-generated content is persisted or published. Now Assist handles generation; a human approves the result before it becomes permanent.

The core capabilities are similar (summarisation, response drafting, knowledge generation) but Now Assist for HR is configured with HR-specific data sensitivity requirements and knowledge sources.

HR cases frequently contain highly sensitive personal data: salary, performance reviews, disciplinary matters, medical leave requests, and termination details. Now Assist for HR is configured to use HR-appropriate LLM access controls, typically using Now LLM (on-platform) or, where external LLMs are used, applying PII masking on HR-specific sensitive fields before sending prompts externally.

The HR Now Assist skills draw from HR knowledge bases (policies, benefits guides, onboarding materials, regulatory compliance documentation) rather than IT knowledge articles. The knowledge source configuration in the Now Assist Admin Console is what separates HR output quality from generic output quality, an ITSM knowledge base produces poor HR answers and vice versa.

Common Now Assist for HR deployments cover: employee enquiry response (benefits, policies, leave), onboarding case summarisation, performance review case handling, employee relations case notes drafting, and knowledge generation from resolved HR cases.

ROI measurement combines metrics from the Now Assist Admin Console and existing ITSM reporting. The calculation maps each Now Assist skill to a time saving, then multiplies by volume and cost.

• Average handle time – Track before and after Now Assist activation. Summarisation and response suggestion typically reduce handle time by 15–25%.
• Documentation time – Time agents spend on resolution notes. Resolution Note Generation typically reduces this from 4 minutes to under 30 seconds per ticket.
• Acceptance rate – Found in the Now Assist Admin Console: the percentage of AI suggestions agents accept without modification. High acceptance means the suggestions are relevant and trusted.

• Search deflection rate – Percentage of users who resolve their issue via AI Search without submitting a ticket.
• Knowledge article throughput – Number of articles published per month. Now Assist typically increases this significantly by reducing the authoring effort per article.

Minutes saved per ticket × ticket volume per month × hourly agent cost = quantified saving. Present this alongside Now Assist Admin Console usage data to build the business case for expanding Now Assist to additional modules.

The Prompt Playbook is a NASK resource that provides tested prompt templates, design patterns, and best-practice guidance for building effective custom Now Assist skills. It is the reference for developers who need to write prompts that produce consistent, high-quality output from the LLM.

• Prompt templates for common skill types: retrieval-augmented generation (RAG), classification, summarisation, structured data extraction, and step-by-step guidance generation
• Guidance on system prompt structure: how to set the role, output format, length constraints, and tone for the LLM
• Input variable patterns: how to reference retrieved content, record field values, and session context in the prompt template
• Anti-patterns to avoid: vague instructions, unconstrained output length, missing output format specification

LLM output quality is directly proportional to prompt quality. A skill with a well-structured prompt that specifies output format, length, role, and constraints produces dramatically more consistent output than one with a generic instruction. The Playbook reduces the experimentation time required to arrive at a high-quality prompt from scratch.

The Model Registry is the NASK component that manages which LLM provider and model each custom skill uses. It is configured through the Generative AI Controller and allows per-skill model selection, independent of the platform-wide LLM default.

A custom skill can specify its own LLM provider independently of other skills. This means an organisation can run:

• An HR policy skill on Now LLM (maximum data sensitivity, no external calls)
• An engineering runbook skill on Azure OpenAI GPT-4o (best reasoning for technical content)
• A customer-facing response skill on Anthropic Claude (preferred writing quality)
• All three running simultaneously on the same instance

The Model Registry tracks the specific model version each skill is configured for. When a provider updates their model (e.g., Azure OpenAI updates the GPT-4o version), the admin can test the new version in a dev environment before updating the registry entry for production skills. This prevents unexpected behaviour changes from model updates affecting production.

NASK skills inherit platform-level content safety filters and can additionally be configured with skill-level guardrails specific to the custom use case.

All NASK skill output passes through ServiceNow's content safety layer before display. This blocks output containing discriminatory language, policy violations, or anomalous PII in unexpected output positions. These run regardless of which LLM provider is configured.

NASK's Script component can validate the input before it reaches the Retriever and LLM. If key required fields are empty or below quality thresholds (e.g., incident Short Description is less than 10 characters), the Script can abort the skill and return a user-friendly message rather than producing a poor-quality LLM output.

After the LLM returns a response, a post-processing Script can validate the output format (e.g., verify the expected JSON structure is present, or that the response length is within acceptable bounds). If validation fails, the Script can either return an error message or request a retry with a refined prompt.

Custom skills that write to records (updating a field, creating a task, triggering a change) should include a human confirmation step before the write action executes. Configure this as a UI confirmation dialog or a Subflow approval step, depending on the stakes of the action.

Skill Chaining connects multiple Now Assist skills in sequence, where the output of one skill becomes the input context for the next. It enables complex multi-step AI workflows that cannot be completed by a single LLM call.

Each skill in a chain receives both the original input (the record context) and the structured output from the previous skill. The developer configures which fields from the previous skill's output to pass as input variables to the next skill's prompt template.

1. Skill 1 retrieves and summarises the 3 most relevant runbooks based on the incident description
2. Skill 2 takes the runbook brief from Skill 1 plus the CI details and generates a numbered remediation plan
3. Skill 3 takes the remediation steps and creates child tasks on the incident, one per step

• When the task requires distinct phases that each need focused LLM attention
• When an intermediate output needs to be validated or transformed by a Script before the next AI step
• When the final output should trigger an automated action (Subflow) based on structured AI-generated data
• When a single prompt becomes too complex to produce reliable output consistently

Building the skill in Now Assist Skill Kit is only the first step. Deployment and ongoing management happen in the Now Assist Admin Console (All → Now Assist Admin Console). NASK is the development framework; the Now Assist Admin Console is where the skill goes live and where its adoption is tracked.

Versioning happens within NASK itself via the Prompt Editor tab. A developer creates a new prompt version, tests it against representative records in dev, and promotes it to active without affecting the currently live version. If a new version degrades output quality, rolling back to the previous prompt version is immediate and does not require a deployment cycle.

Once a skill is published from NASK, it must be activated in the Now Assist Admin Console before agents can use it. Activation is scoped: activate for a specific user group, a department, or globally. This allows staged rollouts: activate for 5 pilot agents first, then expand once the acceptance rate confirms quality.

The Now Assist Admin Console surfaces per-skill usage data: trigger counts, acceptance rates, and agent feedback. These are the signals that tell you whether the skill is being used and whether agents trust its output, not whether it passed developer testing.

Start with data, then work through a structured checklist before concluding it is a model problem.

Low acceptance rate for the Response Suggestion skill confirms the problem is real and widespread. If one agent complains but the acceptance rate is 70%+, the issue may be individual preference rather than a platform problem.

Response suggestions draw from resolved incidents and knowledge articles. If those sources are outdated, too short, or inconsistently written, suggestions will be poor. Check when the knowledge base was last reviewed and what the article quality looks like.

In the Now Assist Admin Console, verify the skill's context sources, which knowledge bases and incident data are being used as input. A skill configured to pull from a low-quality or irrelevant knowledge base will produce poor suggestions.

Gather 3–5 specific cases where the suggestion was wrong. Look for patterns, if all the bad suggestions are for a specific category (e.g., network issues), the problem may be knowledge gaps in that area specifically.

If using a non-default provider (Azure OpenAI or BYOLLM), verify the model version is current and the connection latency is not causing timeouts that truncate context.

Use Now LLM, ServiceNow's on-platform model. It is the only option where data never leaves ServiceNow infrastructure. No external API call is made and no data passes to any third party, even temporarily.

Configure this in the Generative AI Controller by setting Now LLM as the provider for all Now Assist skills. Confirm there are no individual skill overrides pointing to an external provider.

Zero data retention agreements with Azure OpenAI or Claude mean the provider does not store the data after processing, but the data still leaves the ServiceNow platform via an API call. For organisations with absolute data residency requirements (government, defence, some healthcare), “data never crosses the boundary” is the hard requirement. Now LLM satisfies that; zero-retention partners do not.

They operate at different points in the resolution funnel and serve different audiences, so there is no functional overlap.

Virtual Agent handles the user-facing conversation. It deflects L0 and L1 requests (password resets, status checks, FAQ answers) by resolving them autonomously through guided topic flows. The end user never needs to speak to a human agent for these requests.

For requests that Virtual Agent cannot resolve autonomously, a ticket is created and routed to a human agent. That is where Now Assist begins: summarising the conversation history captured by Virtual Agent, drafting the agent's first reply, and accelerating documentation at resolution.

Virtual Agent reduces L1 volume by 30–50%. Now Assist reduces handle time on the remaining tickets by 15–25%. Together they compress both the volume of work and the time per unit of work that reaches a human agent.

The configuration involves the Generative AI Controller for the connection and the Now Assist Admin Console for the skill assignment.

1. Navigate to Generative AI Controller in ServiceNow (System AI → Generative AI Controller)
2. Create a new LLM Provider Connection and select Azure OpenAI as the provider type
3. Enter the Azure OpenAI endpoint URL, API key, and deployment name for the specific model (e.g., gpt-4o)
4. Run the built-in connection test to verify credentials and connectivity
5. Navigate to the Now Assist Admin Console (All → Now Assist → Admin Center)
6. Open the Incident Summarisation skill configuration
7. Change the LLM Provider from Now LLM to the Azure OpenAI connection just created
8. Confirm the client has a zero data retention agreement with Microsoft for their Azure OpenAI deployment before going live
9. Test the skill with a sample incident and compare output quality to the Now LLM baseline

This is a knowledge curation and Now Assist Admin Console configuration task, not a model-level change.

In the Now Assist Admin Console, open the Knowledge Article Generation skill and verify which knowledge bases are configured as context sources. Restrict this to only the knowledge bases that contain reviewed, published articles, exclude draft or unreviewed bases.

Ensure the AI search index only includes articles in Published state. Articles in Draft, Review, or Retired state should not be indexed as context for generation.

Knowledge Article Generation pulls from resolved incident notes. If the concern is that unreviewed resolution notes may produce inaccurate articles, create a Mandatory Knowledge Review workflow that routes all AI-generated draft articles to a knowledge manager before publishing. Do not skip the human review step.

This is a Retriever + Script + LLM pipeline, the most common NASK pattern: retrieve relevant content, optionally pre-process it, generate structured output.

In the Now Assist Skill Kit, create a new custom skill. Define its name, purpose (generate remediation steps from internal runbooks), and the trigger: a UI Action button on the incident form called “Generate Remediation Guide.”

Add a Retriever component pointing to the engineering runbook knowledge base (or a custom table where runbooks are stored). Configure the search context to combine the incident's short description, CI name, and category as the query. Set the retrieval count to 3–5 most relevant runbooks, enough for grounding without overloading the prompt context window.

If the runbook content includes boilerplate sections irrelevant to incident remediation (introduction paragraphs, safety disclaimers, equipment specifications), add a Script component between the Retriever and the LLM call to filter these sections before injection. A focused context produces a more focused output.

System prompt: “You are an IT operations assistant. Generate a numbered step-by-step remediation guide based only on the provided runbooks. If a runbook step does not apply to this specific incident, omit it. Be concise.” User prompt: “Incident: [short_description]. CI: [ci_name]. Runbooks: [retrieved_content].”

Activate the skill in the Now Assist Admin Console, run it against 10 representative incidents in dev, review output quality, refine the prompt and Retriever scope. Pilot with 5 agents before full production rollout.

Inconsistent NASK skill output typically has one of three root causes: variable input quality, inconsistent retrieval, or an under-specified prompt. Work through them in order.

Use the NASK debug mode to inspect what the Retriever is returning for the incidents that produced poor output vs. good output. If the Retriever returns only 1–2 thin chunks for poor-output incidents (because the runbook database has sparse coverage for those CI types), the LLM has little to reason from and falls back to generic output. Fix: add missing runbook content for underrepresented CI categories.

Check whether the poor-output incidents have vague Short Descriptions (e.g., “problem with server” vs. “Oracle DB connection failures on PROD-DB-01”). A vague query produces a vague Retriever result which produces a vague output. Fix: add an input validation Script that scores the Short Description length and warns agents before triggering the skill if it is below a minimum quality threshold.

If both Retriever output and input quality are adequate but output is still variable, the prompt is under-specifying the output format. Add explicit instructions: number of steps (5–8), step format (action verb + specific detail), tone (technical, terse), what to omit (background context, safety warnings). Constrained prompts produce more consistent output.

After each change, run the skill against the same 10–15 test incidents. Track whether output quality variance decreases. Use acceptance rate from a pilot agent group as the final quality gate.

This is an external API Retriever + Script + Skill Chaining design, with a human approval gate before the summary is persisted.

1. Skill 1, Contract Retrieval: An external API Retriever calls the DMS REST API with the contract ID. A post-retrieval Script parses the response and extracts the relevant sections (clauses, definitions, obligations, terms) while discarding boilerplate that adds token cost without informational value.
2. Skill 2, Risk Classification: Passes the extracted sections to the LLM with a structured prompt: “Classify each clause as Standard, Non-standard, or High-risk. For each non-standard or high-risk clause, identify the clause type (Indemnity, Limitation of Liability, IP Ownership, Termination, Data Processing) and explain the risk in one sentence.” Output is structured JSON.
3. Skill 3, Summary Generation: Takes the JSON from Skill 2 and generates a human-readable executive summary: number of clauses reviewed, number flagged, highest-risk items, recommended legal review priority.

Before the summary is written to the Legal case record, a UI confirmation step displays the generated summary for the legal analyst to review. The analyst approves, edits, or rejects before it is persisted. Do not auto-write AI-generated legal risk assessments to records without a mandatory review step.

Legal contract content typically has high data sensitivity. Configure this skill chain to use Now LLM (on-platform, data never leaves ServiceNow) or confirm that the DMS data classification is compatible with the external LLM provider's data agreement before using Azure OpenAI or Claude.