@onlyflows/servicenow-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation5/5
Each tool targets a distinct ServiceNow resource or operation (e.g., query vs. get, create vs. update vs. delete vs. batch, schema vs. discover). No two tools appear to do the same thing, and descriptions reinforce clear boundaries.
Naming Consistency5/5
All tools follow the sn_ prefix and use lowercase snake_case with descriptive words. While some names are nouns (schema, health, syslog), the pattern is uniform and predictable across the entire set.
Tool Count4/5
At 17 tools, the count is slightly above the ideal 3-15 range, but each tool serves a distinct and necessary purpose in ServiceNow administration, making the extra weight reasonable rather than redundant.
Completeness4/5
The set covers comprehensive CRUD, querying, aggregation, schema, health, attachments, relationships, logs, code search, test automation, and scripting. Minor gaps exist—such as no attachment deletion and batch operations not supporting create—but these are edge cases not core to the domain.
Average 3.8/5 across 17 of 17 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fails to disclose important behavioral details such as return format, default limits, or read-only status. It only says 'Discover,' which implies a listing operation, but does not clarify pagination, filtering behavior, or whether results are limited to installed items only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that is front-loaded with the verb and resource list. It contains no filler or redundant information, making it highly concise and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the tool having 4 parameters and no output schema, the description offers only a high-level purpose. It lacks essential context about what the output looks like, how pagination or the limit parameter behaves, and how the active filter applies. This makes it incomplete for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all parameters, including the enum for type and explanations for limit, query, and active. The description adds context by stating the resources are 'installed on the ServiceNow instance,' but does not further elaborate on parameter semantics beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Discover' and clearly names the resources: tables, applications, and plugins installed on the ServiceNow instance. This distinguishes it from sibling tools like sn_query or sn_schema by focusing on installed metadata rather than data querying or schema definitions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention what types of questions it answers or when to prefer sn_schema or sn_query instead, leaving the agent to infer usage solely from the tool name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the full burden. It only states the core action and input; it does not disclose return values, permissions, validation behavior, or consequences of invalid fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, direct and front-loaded, with no redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple and the schema fully covers parameters, but the description omits expected return values, error handling, and any table-specific constraints. Given the lack of annotations and output schema, more context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for both parameters, including examples. The description adds no substantive meaning beyond the schema; it merely restates that field values are passed as a JSON object.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('create') and the resource ('record on any ServiceNow table'), and the creation semantics distinguish it from sibling tools like sn_update, sn_delete, and sn_get.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit usage guidance is provided. It does not mention when to use this tool instead of alternatives like sn_update, nor any exclusions or prerequisites beyond the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description provides no behavioral details beyond the basic operation. It does not mention that the tool is read-only, what permissions are required, rate limits, or the structure of the returned aggregate results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the action, and contains no redundant words. It efficiently conveys the tool's core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters and no output schema, the description is minimal. It explains the core purpose but omits details about return format, error behavior, or constraints, which are important for a query tool with grouping and display_value options.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover all 6 parameters (100% coverage), so the baseline is 3. The description adds only 'optional grouping' which maps to group_by but does not enrich parameter meaning beyond schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs aggregate queries (COUNT, AVG, MIN, MAX, SUM) on a ServiceNow table with optional grouping, distinctly differentiating it from sibling tools like sn_query or sn_get that retrieve raw records.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied via the aggregation verbs and table context, but no explicit guidance is given about when to choose this tool over alternatives like sn_query for raw data, or any exclusions for unsupported aggregate types or table restrictions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of disclosing side effects and behavior. It implies a read-only operation through 'traverse' and 'impact analysis,' but it does not explicitly state that it makes no modifications, nor does it describe the output structure, behavior when no starting point is provided, or resource implications of deep graph walks. This is a significant transparency gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action, no filler. Every phrase adds context (graph walk, directions, depth, use cases). Highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 7 optional parameters with no required ones, but logically a starting CI (sys_id or ci_name) is necessary for traversal. The description does not state this requirement or what happens if neither is provided. There is no output schema, and the description fails to mention what the return value looks like (e.g., list of relationships, graph nodes, depth-limited results). This is incomplete for a complex graph-walk tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already documents (e.g., direction, depth, impact mode). It mentions 'both directions' and 'depth' in prose, but these are already in the schema. No value added beyond the structured fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Traverse CMDB CI relationships (graph walk)', clearly distinguishing this from sibling tools like sn_query or sn_get that fetch individual CIs. It also names concrete use cases (impact analysis, dependency mapping) and the key modes (upstream/downstream/both, depth).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Use for impact analysis and dependency mapping,' providing clear context for when to invoke this tool. It does not explicitly name alternatives or when not to use it, but the differentiation from siblings is inferred by the traversal focus, and the 'Use for' phrase offers concrete guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. While it implies a partial update ('field values to change'), it does not disclose side effects, error handling, authorization requirements, or what happens if the record does not exist. For a mutation tool, this is insufficient behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose, and contains no filler. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description should explain return values or failure modes. It does not mention what the tool returns after an update (e.g., updated record, success indicator), nor does it cover edge cases. For a 3-parameter mutation tool, the description feels incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with clear descriptions for all three parameters (table, sys_id, fields). The description adds minimal extra meaning beyond restating 'Pass the sys_id and field values,' so it does not elevate beyond the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Update an existing ServiceNow record.' The verb 'Update' and resource 'ServiceNow record' are specific, and it distinguishes from sibling tools like sn_create (create) and sn_delete (delete) by explicitly saying 'existing.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context that this is for updating existing records and instructs to 'Pass the sys_id and field values to change.' However, it does not explicitly mention when not to use it or name alternative tools such as sn_create or sn_batch, so it falls short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. It mentions 'run' (mutation) but does not warn about potential side effects like executing test suites, asynchronous behavior, or system impact. The wait/timeout parameters exist in the schema, but the description does not explain the synchronous nature or implications of running tests. This is a significant gap for a tool that triggers executions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 13 words, front-loaded with the tool's name and core operations. It is concise with zero filler, every word contributing to the purpose. The em dash effectively introduces the function list, making it highly scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (10 parameters, multiple actions, no output schema or annotations), the description provides only a minimal overview. The schema fills in parameter details, but the description lacks guidance on the test lifecycle (e.g., list → run → results), potential delays, or error scenarios. It is adequate for basic selection but incomplete for safe and effective invocation in all but the simplest use cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds a high-level overview but does not enhance the meaning of individual parameters beyond what the schema already provides. For example, 'action' is fully described in the enum, and the description does not add any new semantic context to parameters like 'query', 'wait', or 'timeout'. It neither improves nor harms parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's domain ('Automated Test Framework') and its primary operations ('list, run, and get results for ATF tests and test suites'). This distinguishes it from sibling tools like sn_query or sn_script, as it is specifically for ATF test management. The verb-resource pairing is explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates clear use cases: listing, running, and retrieving results for ATF tests/suites. While it doesn't explicitly mention alternatives or when-not-to-use, the ATF-specific naming inherently separates it from generic query or script tools. No exclusions are provided, but the context is clear enough for an agent to infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It lists the three operations but does not describe potential side effects (e.g., upload overwriting, download requiring specific permissions), authentication requirements, or error handling. This is a notable gap for a tool that includes a mutating action (upload).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the tool's purpose and lists the three operations. Every word earns its place with no redundant detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides a high-level overview but does not explain which parameters are needed for each action (e.g., table and sys_id for list/upload vs attachment_sys_id for download). With 7 parameters and no output schema, additional context on action-parameter mapping and return values would improve completeness, though the schema partially covers this.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents each parameter's purpose and which are required for specific actions. The description adds no additional semantic meaning beyond the operation names, so it meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Manage attachments on ServiceNow records. List, download, or upload attachments.' clearly identifies the tool's purpose with a specific verb ('manage') and resource ('attachments'), and it enumerates the three distinct operations. This also distinguishes it from sibling tools, which focus on other record operations like querying or creating records.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context that this tool is for attachment operations (list, download, upload), which implies when to use it versus sibling tools focused on other aspects of ServiceNow records. However, it does not explicitly state when not to use it or name alternative tools, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the return behavior ('Returns all fields or a specified subset') but does not mention error handling, permissions, or the effect of the display_value parameter. Some transparency is present, but gaps remain.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loads the main purpose, and contains no fluff. Every word is informative, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple get tool with no output schema. The description explains return behavior and scope, which is adequate. However, it doesn't mention the display_value parameter's effect or error behavior, but given the simplicity and schema coverage, it's nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all four parameters. The description adds no additional meaning beyond the schema, e.g., it doesn't elaborate on the fields parameter beyond 'specified subset.' Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Get a single ServiceNow record by sys_id.' It uses a specific verb and resource, and the word 'single' distinguishes it from sibling tools like sn_query, which likely retrieves multiple records.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the word 'single' but does not explicitly state when to use this tool versus alternatives like sn_query, nor does it provide exclusion criteria or mention any prerequisites. The guidance is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states the return contents (field names, types, max lengths, mandatory flags, reference targets) but does not explicitly confirm that it is read-only, mention authorization needs, or describe potential error conditions. The verb 'Get' implies a safe read, but a few edges are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately states the purpose and then lists the returned fields. There is no redundant or unnecessary wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (2 parameters, no output schema), and the description adequately covers the key aspects: what the tool does and what it returns. It does not mention the fields_only parameter, but the schema covers that, so the description is complete enough for this straightforward tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already fully documents both parameters (table and fields_only). The description does not add any extra parameter semantics beyond what the schema provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Get') and resource ('schema (field definitions) for a ServiceNow table'), and lists what is returned. This distinguishes it from siblings like sn_query or sn_get that fetch records rather than table metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (when needing field definitions for a table) but does not explicitly mention alternatives or exclusions. No guidance is given on when not to use it or how it compares to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description must disclose behavioral traits. It mentions the confirm flag safety measure but doesn't state that deletion is permanent or irreversible, nor does it mention permissions or consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences, front-loading the action and purpose, with no superfluous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core function and the confirm requirement, but given the destructive nature of the operation and lack of an output schema, it omits important context such as whether deletion is permanent or any success/failure return information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for all three parameters (table, sys_id, confirm). The description adds no additional parameter semantics beyond restating the confirm requirement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: deleting a ServiceNow record by sys_id. This distinguishes it from sibling tools like sn_create, sn_update, and sn_get, which handle other CRUD operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use it — when deleting a record — and notes the confirm flag requirement. However, it doesn't explicitly mention alternatives or when not to use it, such as for bulk deletions (which might be handled by sn_batch).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the tool returns matching records with code snippets, but does not cover permissions, rate limits, or any side effects. As a read-only search, this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and resource, and every word earns its place. It is clear and efficient without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with no output schema, the description explains the return value (matching records with code snippets) and the domain. It relies on the well-documented schema for parameter details, which is appropriate. Minor missing details like ordering or pagination are not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema descriptions already cover all parameters at 100%, so the tool description adds no extra parameter-level meaning. The baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Search across') and identifies a specific resource ('ServiceNow code artifacts') with a clear enumeration of artifact types. This distinguishes it from generic search tools like sn_query and sn_discover.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool (searching code artifacts) and implies its scope, but it does not explicitly name alternatives or exclusions. Since siblings exist, the absence of explicit 'use this instead of X' guidance prevents a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It does state what is checked, which is useful, but it does not explicitly say whether the operation is read-only, whether it requires elevated privileges, or what the response format looks like. It also doesn't mention any potential side effects from the health checks.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that is front-loaded with the primary action and resource. Every phrase adds relevant detail without padding or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional enumerated parameter and no output schema, the description provides a solid overview of the health areas covered. It does not explain the return format or error behavior, but given the low complexity, this is a minor gap rather than a critical omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with an enum, so the baseline is 3. The description adds meaning by mapping specific health categories ('version, cluster nodes, stuck jobs, semaphores, key stats') to the enum values, clarifying what each check encompasses beyond the schema's generic 'Which health check to run'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Check' with the clear resource 'ServiceNow instance health' and enumerates concrete sub-areas (version, cluster nodes, stuck jobs, semaphores, key stats). This clearly distinguishes it from sibling tools like sn_query, sn_get, or sn_discover, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage as a health-monitoring tool, and the enumerated checks give context. However, it provides no explicit guidance on when to use this instead of alternatives (e.g., sn_get or sn_query), no prerequisites, and no mention of when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'Returns records' and highlights support for field selection, pagination, sorting, and display values, giving useful context about the tool's behavior. While it doesn't explicitly declare this as a read-only operation, the term 'Query' strongly implies it, and no contrary annotations exist. This is more than adequate for a non-destructive tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the main purpose ('Query any ServiceNow table') and immediately lists the key features. There is zero wasted words or redundancy, making it highly concise and effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no output schema), the description covers the core purpose and capabilities sufficiently. It does not explain the response structure in detail, but the statement 'Returns records' gives a general expectation. Since the schema already documents parameters thoroughly, the description is nearly complete, though a note on response format would make it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter having a detailed description (e.g., query syntax, sort prefix, display modes). The tool description itself adds no additional parameter meaning, so the baseline of 3 is appropriate when the schema already documents parameters well.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Query' with the resource 'any ServiceNow table', clearly stating the tool's function. It also lists key capabilities (field selection, pagination, sorting, display values) which distinguish it from sibling tools like sn_get or sn_aggregate. This meets the benchmark for a specific and differentiating purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: this is for querying ServiceNow tables. However, it does not explicitly state when to use this tool over alternatives (e.g., sn_get for single records, sn_aggregate for summary queries) or provide any exclusions. The context is clear but lacks explicit guidance about alternatives, so it falls short of a 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses ordering ('newest first') and implies read-only via 'Query', but does not mention default limits, raw query override behavior, or any potential limitations. This is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 18 words, front-loaded with the purpose. It includes a useful behavioral detail (ordering) without any fluff, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the thorough parameter schema, the description is sufficient. It does not explain return values, but none is required since there is no output schema. It omits mention of the raw query override and default limits, but these are covered in the schema descriptions, making the overall package complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all 7 parameters with detailed descriptions (100% coverage), so the baseline is 3. The description's mention of 'severity, source, and time-based filters' partially maps to level, source, and since, but adds minimal value over the schema's existing documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Query') and clearly identifies the resource ('ServiceNow system logs (syslog table)') along with the filter dimensions (severity, source, time-based) and result ordering. This distinguishes it from generic sibling tools like sn_query or sn_get.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (querying the syslog table) but does not explicitly mention alternatives or exclusions. The sibling list includes sn_query, which could be ambiguous, but the specialization for syslog is evident from the resource designation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently reveals the dry-run default, the need to set confirm=true to execute, and the safety cap, which is especially critical for a batch mutation tool. It does not disclose return values or error states, but the safety mechanisms are prominent and well-communicated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the core purpose front-loaded and every word earning its place. It is direct, efficient, and free of fluff, providing the essential operational facts in minimal space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (batch operations, nested objects, no annotations or output schema), the description covers critical operational context: bulk nature, dry-run behavior, and safety cap. It omits return value/error details, but with no output schema, this is less critical. The schema fills parameter-level gaps, making the description reasonably complete for safe usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the schema itself already documents parameters like confirm (default dry-run) and limit (safety cap 10000). The description repeats these points without adding new parameter-level meaning. It does not clarify encoding of query or fields beyond what the schema already provides, so it fails to add value beyond the structured fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Bulk update or delete records matching a query.' It uses a specific verb (update/delete) and resource (records), and the 'Bulk' prefix distinguishes it from single-record siblings like sn_update and sn_delete. Additional details about dry-run and safety cap reinforce its unique identity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool via the 'Bulk' qualifier, contrasting with single-record operations. It also provides clear execution guidance: dry-run by default, set confirm=true to execute, and a 10,000-record safety cap. However, it does not explicitly mention alternatives for single-record operations, so it stops short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that read operations execute immediately while write operations require execute=true, which is a critical behavioral distinction. It does not disclose other potential behaviors like failure modes, permissions, or idempotency, but the most important execution semantics are addressed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the tool's essence, and contains no redundant or filler content. Every sentence contributes: what it is, what it supports, and the key execution rule.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (supports many operation types) and the lack of annotations or output schema, the description provides a good high-level overview. It covers the range of operations and the critical execute semantics. It does not mention return formats or limitations, but for a natural language interface, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for all four parameters (text, force, confirm, execute), so schema coverage is 100%. The description adds a useful note about execute=true for writes but does not elaborate on force or confirm beyond what the schema states. Thus, the description adds minimal extra meaning over the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states this is a natural language interface for ServiceNow that translates plain English into API calls. It lists supported operations (queries, aggregates, schema lookups, creates, updates, batch), distinguishing it from the specific sibling tools like sn_query or sn_create. The verb 'translates' and resource 'ServiceNow' make the purpose explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: use this when the user provides a natural language request. It mentions supported operation types and execution semantics (reads execute immediately, writes need execute=true). However, it does not explicitly state when not to use it or explicitly point to sibling tools as alternatives, leaving some ambiguity about whether direct tools are preferred for programmatic or precise operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden and discloses key behavioral traits: admin role requirement, server-side execution, gs.print() return behavior, and the optional Playwright dependency. It does not explicitly mention that scripts may modify data, but the schema already covers the confirm parameter for destructive keywords.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the main purpose, followed by execution details and a dependency note. Every sentence adds value with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a script execution tool with 4 parameters and no output schema, the description covers the core purpose, output mechanism, auth prerequisite, and a unique dependency. It could mention potential side effects or error handling, but the schema handles the confirm parameter and the description is otherwise comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds minimal parameter-specific value beyond the schema—it mentions GlideRecord/GlideSystem and gs.print() but does not elaborate on scope, confirm, or timeout behavior. The schema already documents these parameters sufficiently.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool executes background scripts on the ServiceNow instance, specifically server-side GlideRecord/GlideSystem JavaScript, returning gs.print() output. This verb+resource combination distinguishes it from sibling tools like sn_query or sn_update, which perform standard operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it is for executing custom server-side JavaScript, requires admin role, and returns gs.print() output. It does not explicitly name alternatives or when-not-to-use, but the custom-script context implicitly differentiates it from CRUD-focused siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![servicenow-mcp MCP server](https://glama.ai/mcp/servers/onlyflowstech/servicenow-mcp/badges/card.svg)](https://glama.ai/mcp/servers/onlyflowstech/servicenow-mcp)

Score Badge

Copy to your README.md:

[![servicenow-mcp MCP server](https://glama.ai/mcp/servers/onlyflowstech/servicenow-mcp/badges/score.svg)](https://glama.ai/mcp/servers/onlyflowstech/servicenow-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/onlyflowstech/servicenow-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server