abnormal-mcp is an MCP server for Abnormal Security that enables AI-powered email threat detection, investigation, case management, and remediation.
Navigate & Discover: Use abnormal_navigate to explore available tools by domain (threats, messages, remediation, abuse, cases) and abnormal_status to check connection status.
Threat Management: List paginated detected threat cases (abnormal_threats_list) and retrieve full details of a specific threat by ID (abnormal_threats_get), including classification, severity, and related messages — rendered as an interactive card in compatible MCP Apps hosts (e.g., Claude Desktop/web).
Message Analysis: List all messages within a threat case (abnormal_messages_list) and get deep analysis of individual emails (abnormal_messages_get), including headers, URLs, attachments, and AI-based threat assessment.
Remediation: Trigger email remediation to remove a malicious message from mailboxes, restore it (unremediate), or check the current remediation status (abnormal_remediation_manage).
Abuse Mailbox: List and review phishing emails reported by users (abnormal_abuse_list), including whether Abnormal confirmed the threat.
Security Cases: List active security investigation cases (abnormal_cases_list) and retrieve detailed information about a specific case (abnormal_cases_get), including status, analyst notes, associated threats, and timeline.
MCP server for Abnormal Security — AI-powered threat detection, case management, and email remediation.
This server uses a decision-tree architecture. Start by calling abnormal_navigate to select a domain, then use the domain-specific tools.
Tool | Description |
| Navigate to a domain (threats, messages, remediation, abuse, cases) |
| Return to domain selection |
Tool | Description |
| List detected threat cases (paginated) |
| Get full details of a specific threat by ID |
Tool | Description |
| List messages within a threat case |
| Get detailed message analysis (headers, URLs, attachments, AI analysis) |
Tool | Description |
| Trigger or check remediation actions for a message |
Tool | Description |
| List phishing emails reported via the Abuse Mailbox |
Tool | Description |
| List active security investigation cases |
| Get details of a specific case |
abnormal_threats_get renders as an interactive threat card in MCP Apps
hosts (Claude Desktop/web): subject, sender, attack classification,
remediation status, and the messages in the threat. The card is read-only —
remediation stays a deliberate, model-mediated action. Plain-JSON behavior
is unchanged in other hosts. Neutral by default, brandable via
window.__BRAND__ injection or MCP_BRAND_* env vars (MCP_BRAND_NAME,
MCP_BRAND_LOGO_URL, MCP_BRAND_PRIMARY_COLOR, MCP_BRAND_ACCENT_COLOR,
MCP_BRAND_BG, MCP_BRAND_TEXT) — no rebuild needed.
Related MCP server: blumira-mcp
Abnormal Security uses Bearer token authentication.
export ABNORMAL_API_TOKEN=your-api-token
node dist/index.jsGenerate your token in the Abnormal portal under Settings > Integrations > API.
When deployed behind the MCP gateway, set AUTH_MODE=gateway. The gateway injects the Authorization: Bearer {token} header automatically on each request.
npm install
npm run build
node dist/index.jsMCP_TRANSPORT=http AUTH_MODE=gateway node dist/index.jsdocker compose upnpm install
npm run dev # watch mode
npm test # run tests
npm run typecheck # TypeScript type check
npm run build:ui # rebuild the MCP Apps card bundle (only needed when ui/ changes)Apache-2.0
List phishing emails reported by users via the Abuse Mailbox. Returns user-submitted reports with analysis results indicating whether Abnormal confirmed the threat.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | OData filter expression (e.g. 'firstReportedTime gt 2024-01-01T00:00:00Z') | |
| pageSize | No | Number of results per page (default: 100, max: 100) | |
| pageNumber | No | Page number to retrieve (1-indexed, default: 1) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations; description covers read operation but lacks details on pagination, rate limits, or any destructive behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences are concise and front-loaded, though could be slightly more condensed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequately covers purpose and return value for a list tool with 3 parameters and no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters with descriptions; description does not add additional meaning beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it lists phishing emails reported via Abuse Mailbox and returns analysis results. Distinguishes from siblings like abnormal_threats_list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage for fetching user-reported phishing incidents, but no explicit when-to-use or comparisons with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific security case by ID. Returns case status, analyst notes, associated threats, and timeline.
| Name | Required | Description | Default |
|---|---|---|---|
| caseId | Yes | The numeric case ID to retrieve |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description transparently states that it returns case status, analyst notes, associated threats, and timeline. This is sufficient for a read-only operation without side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the tool's purpose and return content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one required parameter and no output schema, the description adequately covers what the tool does and what it returns (status, notes, threats, timeline). It is complete for this simple retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter 'caseId' described as 'The numeric case ID to retrieve'. The description adds no additional meaning beyond what the schema provides, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states 'Get detailed information about a specific security case by ID' with a clear verb (Get) and resource (security case). It clearly distinguishes from siblings like abnormal_cases_list (which lists cases) and other detailed get tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a specific case ID but does not explicitly state when to use this tool versus alternatives. No when-not-to-use or alternative comparison is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all active security investigation cases in Abnormal Security. Cases group related threats for analyst review and workflow management.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | OData filter expression (e.g. 'createdTime gt 2024-01-01T00:00:00Z') | |
| pageSize | No | Number of results per page (default: 100, max: 100) | |
| pageNumber | No | Page number to retrieve (1-indexed, default: 1) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral transparency. It communicates that only 'active' cases are returned, which is a meaningful behavioral trait, and that cases group related threats—useful context for what the returned data represents. However, it does not disclose pagination behavior beyond what the schema already shows, nor does it mention authentication requirements, rate limits, or the absence of certain fields. Given the simple read/list nature, the disclosure 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single focused sentence that front-loads the main action and resource, and adds one clarifying clause about cases grouping threats. It is appropriately sized with no filler. It could arguably use one more sentence for usage guidance, but as written it is concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with zero required parameters, full schema coverage, and no output schema, the description is mostly sufficient: it names the resource, the active-case scope, and the grouping concept. Gaps include not mentioning the default page size, not explaining what fields will be returned (though no output schema exists), and not differentiating from the sibling get tool. These are moderate gaps rather than fatal ones.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 minimal parameter-level meaning: it does not explain the OData filter syntax, page size limits, or page numbering beyond what the schema already states. No extra semantics are needed for an agent to call it, but it also does not add value like examples of valid filter expressions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List') and resource ('active security investigation cases in Abnormal Security'), and clarifies that cases group related threats for analyst review and workflow management. However, it does not explicitly differentiate itself from its sibling abnormal_cases_get, which is a close cousin that retrieves case details—though the 'List' verb plus the pagination parameters make the list intent clear enough.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use or alternative guidance. The phrase 'active security investigation cases' implies a read-only listing use case, and the pagination parameters imply enumeration, but it does not name sibling tools like abnormal_cases_get or abnormal_threats_list as alternatives for getting details or related threats. The context is clear enough for a simple list call but leaves selection reasoning to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed analysis of a specific message within a threat case. Returns full message metadata, headers, URLs, attachments, and AI-based threat analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| threatId | Yes | The threat ID (UUID) that contains the message | |
| messageId | Yes | The message ID to retrieve (URL-encoded email message ID) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It lists return contents (metadata, headers, URLs, attachments, AI analysis), which is helpful. It does not mention idempotency, error conditions, or permissions, but for a retrieval tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, clear sentence followed by return data list. No fluff, front-loaded key information. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with two parameters and no output schema, the description covers purpose and return data. Could add context about prerequisites (must have threatId from a list), but overall complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear parameter descriptions. The tool description adds minimal extra meaning beyond 'within a threat case'. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the specific resource 'detailed analysis of a specific message within a threat case'. It distinguishes from siblings like abnormal_messages_list (lists messages) and abnormal_threats_get (gets threat details).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need detailed analysis of a specific message, but does not explicitly exclude when to use alternatives or provide negative guidance. It is clear enough for an agent to infer appropriate use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List messages contained within a specific threat case. Returns message IDs and summary data for all emails associated with the threat.
| Name | Required | Description | Default |
|---|---|---|---|
| threatId | Yes | The threat ID (UUID) to list messages for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description must carry the full behavioral burden. It states the return content (message IDs and summary data) but does not disclose whether the operation is read-only, any side effects, permissions required, or limits/pagination. This is a notable gap given zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The primary action and return value are front-loaded, making it immediately scannable and free of unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with only one parameter and no output schema, the description adequately covers what it returns (message IDs and summary data). It does not describe potential pagination or sorting, but for such a simple list operation, the description is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the threatId parameter is fully described in the schema. The description adds no extra semantic detail beyond what the schema already provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List messages') and the resource ('within a specific threat case'). It distinguishes from siblings like abnormal_messages_get (singular message) and abnormal_threats_list (list threats) by specifying the message listing scope, though it does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus sibling tools such as abnormal_messages_get or abnormal_threats_list. The description implies it is for listing all messages associated with a threat, but it does not clarify scenarios where a single message fetch would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Trigger or check the status of a remediation action for a specific threat message. Supports requesting remediation (removal from mailboxes) or checking current remediation status.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform: 'remediate' removes the message, 'unremediate' restores it, 'status' checks current state | |
| threatId | Yes | The threat ID (UUID) containing the message to remediate | |
| messageId | Yes | The message ID to remediate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that 'remediate' removes messages and 'unremediate' restores, but does not mention authentication, rate limits, or side effects. No annotations provided, so description partially fulfills the burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the main verb and resource, no redundant words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers action semantics well but lacks information about return values, especially for the 'status' action, and does not mention prerequisites like already having a threatId from another tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the description adds value by explaining the meaning of each action enum ('remediate' removes, 'unremediate' restores, 'status' checks), going beyond the schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it triggers or checks the status of a remediation action for a specific threat message, distinguishing it from sibling tools that list or get threats/cases.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when remediation or status checking is needed, but lacks explicit guidance on when not to use or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show connection status and available domains
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden, but it only says 'show', which suggests a read-only operation but doesn't explicitly disclose safety (e.g., no side effects, no data mutation). It also doesn't mention whether authentication is required, any rate limits, or the response format. For a status tool, it would be helpful to state it's non-destructive and safe to call.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no fluff. It front-loads the purpose. It could potentially be improved by adding a bit more context, but as is, it is concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a status tool, the description is too thin. An agent benefits from knowing what 'connection status' includes (e.g., API, auth), what 'available domains' means, and whether this should be called first. The description is adequate for a trivial tool but leaves gaps for a status check.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the description doesn't need to explain parameter semantics. The baseline is 4 for 0 params, which fits. The description correctly implies no parameters are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear purpose: it shows connection status and available domains. It is a specific resource (connection status) and result (domains), but it doesn't distinguish it from siblings like abnormal_cases_get or abnormal_threats_list, which are also about showing information. The verb 'show' is explicit, but the description is generic compared to the granular siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. There are no prerequisites, no conditions like 'use this when checking connectivity before other operations', and no mention of alternative tools. The description implies it's a general status check, but it doesn't state when that is preferred over other operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific threat case by ID. Returns threat details including classification, severity, and related message IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| threatId | Yes | The unique threat ID (UUID format) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool returns threat details (classification, severity, message IDs) but does not mention side effects, authorization requirements, or error behavior. This is adequate but leaves gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted wording. The purpose is front-loaded, and the description is efficiently structured for quick parsing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (1 parameter, no output schema), the description adequately covers what is returned. However, it does not differentiate from other get tools like abnormal_cases_get, and sibling tools are not referenced. Slightly above average completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully describes the single parameter threatId as a UUID with 100% coverage. The description adds no additional semantic value beyond restating the parameter's purpose, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'detailed information about a specific threat case by ID'. It distinguishes from siblings like abnormal_threats_list (which lists threats) and abnormal_cases_get (which gets a different entity).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for a single threat when you have its ID, and the sibling tools list includes abnormal_threats_list for listing, but it does not explicitly state when to use this versus alternatives or mention prerequisites like needing a valid threat ID.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List detected threats and cases from Abnormal Security. Returns a paginated list of threat IDs with summary information.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | OData filter expression (e.g. 'receivedTime gt 2024-01-01T00:00:00Z') | |
| pageSize | No | Number of results per page (default: 100, max: 100) | |
| pageNumber | No | Page number to retrieve (1-indexed, default: 1) |
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 states the tool is paginated and returns threat IDs with summary information, which is useful. It does not mention read-only status, authentication needs, rate limits, or what exactly 'summary information' contains.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that gets straight to the point: what is listed, the source system, and the return shape. There is no filler or redundant restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with fully described parameters, the description is mostly sufficient. However, there is no output schema, and 'summary information' is vague; the agent cannot predict the exact response structure or pagination metadata. The ambiguity around 'threats and cases' also leaves a gap in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 filter, pageSize, and pageNumber. The description adds no extra parameter semantics beyond saying the result is paginated, which the schema already communicates through pageSize/pageNumber.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and names the resource ('detected threats and cases from Abnormal Security'), so an agent can tell this is a listing operation. However, the phrase 'threats and cases' is ambiguous next to sibling abnormal_cases_list, and the mention of 'threat IDs' muddies whether cases are actually included.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to choose this tool over abnormal_cases_list, abnormal_threats_get, or abnormal_cases_get. The description implies a listing use case but provides no exclusions or alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.2.5abnormal_cases_listabnormal_messages_listabnormal_navigateabnormal_statusabnormal_threats_listv1.2.0abnormal_cases_listabnormal_messages_listabnormal_navigateabnormal_statusabnormal_threats_listv1.0.0abnormal_abuse_listabnormal_cases_getabnormal_cases_listabnormal_messages_getabnormal_messages_listabnormal_navigateabnormal_remediation_manageabnormal_statusabnormal_threats_getabnormal_threats_listEach tool targets a distinct resource-action pair, but cases and threats can be slightly confused since both have get-by-ID tools. The descriptions clarify that cases group related threats, so agents should mostly select correctly, though the boundary could be clearer.
The pattern abnormal_<resource>_<verb> is mostly consistent (list/get for cases, threats, messages), but abnormal_navigate and abnormal_status break the pattern, and remediation_manage uses a vaguer verb. Overall, the convention is clear and predictable with only minor exceptions.
10 tools is well within the sweet spot for a security-focused MCP server. The count covers the major domains (cases, threats, messages, remediation, abuse reporting) without unnecessary bloat.
The core read-heavy workflows are well covered: list/get cases, threats, messages, plus remediation and abuse reports. Notable gaps include the lack of an update-case or update-threat operation, and abuse reports only support listing without a get-detail tool, but these are minor for a typical analyst workflow.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Cybersecurity MCP server for URL scanning, threat intelligence, and domain reputation.
Email safety MCP server. Detects phishing, prompt injection, CEO fraud for AI agents.
Remote MCP server bridging AI clients with the PowerDMARC email authentication Platform.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/WYRE-AI/abnormal-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server